Amiga Games: Greatest Hits 1996/Amiga Games: Greatest Hits 1996.iso/archive/spiele/demoversionen/doopsi.lha/Doopsi/docs/DOOPSI_Ita.guide

Amigaguide Document | 1996-07-02 | 111KB | 2,385 lines

*************
Introduzione.
*************
Il nome del gioco.
Doopsi-GS significa:  Dinamical Object Oriented Programming System
Interface - Game System.  Abbiamo dato questo nome al nostro programma per
vari motivi:  ci ricorda Boopsi, ovvero l'interfaccia Intuition Orientata
agli Oggetti del nostro beneamato Amiga;
 un programma Orientato agli
Oggetti nel senso tecnico del termine, cio
 per quanto riguarda la sua
struttra interna (qualche notizia di questa struttura
 riportata nell'
Appendice C);
 un'Interfaccia di Programmazione poich
 semplifica il
compito di programmazione rendendolo completamente automatico e veloce.
Questo Sistema di Programmazione
 molto diverso dagli altri prodotti
dedicati al medesimo scopo poich
 estemamente semplice da usare, anche
per coloro che avessero poca abilit
 di programmazione:  l'utente disegna
tutta la grafica e fornisce tutti i suoni e le musiche di cui necessita e
poi il nostro programma mette tutto assieme.  L'idea che giace sotto il
funzionamento di questo programma
 immediata:  voi definite prima di tutto
le scene, poi ponete alcuni oggetti in esse e, infine, specificate come
ciascun oggetto deve reagire quando il giocatore agisce su di esso (questa
 l'unica parte di programmazione che dovete affrontare).  Per essere
sincero vi sono altre parti del lavoro che non ho incluso nella descrizione
precedente, ma le imparerete man mano che verrete maggiormente coinvolti in
Doopsi:  per esempio, uno dei compiti che dovrete affrontare
 quello di
costruire il percorso lungo il quale l'Omino cammina (l'Omino con la
maiuscola
 il protagonista dell'avventura), oppure un'altro compito
quello di scrivere i dialoghi fra l'Omino e qualche altro oggetto, e cos
Queste sono alcune caratteristiche di Doopsi:
- sensibile al sistema operativo (funziona sotto V37+).
- completamente localizzabile (usa la nostra "locator.library" per cambiare
    linguaggio, ma nelle future versioni lo adatteremo alla standard
    "locale.library" se riusciremo a farla funzionare sotto V37).
- compatibile AGA.
- l'Editor
 completamente system friendly.
- gestisce bitmap pi
 grosse dell'area di schermo (con autoscroll).
- permette di suonare moduli e campionamenti durante il gioco.
- completamente personalizzabile (ad es.: potete anche ridisegnare la
   pulsantiera del Player).
Doopsi
 costituito da due programmi indipendenti:  l'Editor ed il Player.
Come i loro nomi possono suggerire, l'Editor
 quello che costruisce
l'avventura, mentre il Player sfrutta i dati prodotti dall'Editor per farvi
giocare.  E' come se l'Editor generasse una specie di programma ed il
Player fosse l'interprete di tale programma:  se si verifica un errore
durante l'esecuzione il Player visualizza un messaggio di errore e, se pu
continua l'elaborazione del gioco, come un qualsiasi interprete di un
qualunque linguaggio farebbe (i linguaggi reali per
 non possono continuare
dopo un errore, ma noi siamo migliori e possiamo!).
Il manuale ha la seguente struttura:  questa sezione introduttiva
 seguita
dalla descrizione della procedura di installazione.  Poi iniziamo con la
Finestra Principale dell'Editor Doopsi, contenente la descrizione di tutti
i (numerosi) bottoni che appaiono (non vi spaventate, imparerete presto ad
usarli).  Dopo la Finestra Principale vi sono tre sezioni dedicate ai tre
editor relativi alla costruzione della scena:  il Path Editor, lo Spot
Editor e lo Screen Attributes Editor.  Seguono le sezioni dedicate agli
oggetti e che descrivono rispettivamente:  l'Object Attributes Editor, il
Doopsi Coder e l'Anim Editor.  Rimangono solo due editor, e questi
costituiscono il soggetto delle sezioni seguenti:  il Dialog Editor e
l'Editor di Preferenze.  La parte principale del manuale
 finita ma
abbiamo anche tre appendici:  la prima descrive tutte le istruzioni del
Linguaggio Doopsi (il Linguaggio Doopsi
 usato nel Doopsi Coder per
programmare gli oggetti); la seconda descrive il profilo della console
inclusa nel pacchetto (la console
 la parte bassa del gioco, quella con le
azioni); e la terza contiene alcuni dettagli tecnici a proposito della
struttura interna degli Oggetti Doopsi (questa non
 necessaria ad una
prima lettura, ma
 inclusa per utenti pi
 esperti (o pi
 curiosi)).  Anche
il Player abbisogna di un minimo di spiegazione, e lo descriviamo
nell'ultima sezione del manuale, situata dopo tutte le appendici.  Questo
tutto, gente.
Una osservazione:  probabilmente questo manuale
 un po' caotico, nel senso
che le informazioni utili sono sparpagliate ovunque e nascoste fra mucchi
di rifiuti.  Questo significa che dovete essere pi
 attenti nel leggere, in
modo da non saltare alcune nozioni interessanti (e vitali).  Siamo
spiacenti, ma questa
 solo la prima versione e continueremo a sistemarla
in modo da migliorarla.  Dunque ogni commento
 gradito, e terremo anche
una lista di FAQ nelle nostre pagine Web.
---------------------------------------------------------------------------
***************************************************
Gli autori (la parte pi
 interessante del manuale):
***************************************************
questa
 la situazione fino al 27 - 6 - 1996 (data del primo upload):
Andrea si
 appena laureato in Fisica all'Universit
 di Milano, e sta
studiando per entrare in un corso di Dottorato.
Fabio sta lavorando come capo progetto presso la DeAgostini Multimedia
di Milano. Ama gli Amiga, i dolci, le ragazze, divertirsi, programmare a
oggetti e DOOPSI ;)
I nostri indirizzi sono:
      Fabio Rotondo                    Andrea Galimberti
      c.so Vercelli, 9                 via Villoresi, 87
      28100 Novara                     20029 Turbigo (Mi)
      Italia                           Italia
      E-Mail: [e-mail]
      Phone: (ITA) - (0)321 - 459676   Phone: (ITA) - (0)331 - 871009
Le pagine Web sono:
      http://www.intercom.it/~fsoft/doopsi.html    -> DOOPSI Home Page!!!
      http://www.intercom.it/~fsoft                -> Fabio Soft Home Page
DOOPSI Mailing list:
      per iscriversi mandare una mail a:
         [e-mail]
      con:
         SUBSCRIBE DOOPSI your_name@your_email.addr
      nel corpo del messaggio.
---------------------------------------------------------------------------
***************
Ringraziamenti:
***************
Mik and Gio of ClassX:   per alcune utili routine. Per il loro supporto,
                         per le loro idee, per essere loro.
Giorgio Fornara:     per la grandiosa grafica della Demo che non
 inclusa
                     in questo pacchetto, ma che apparir
 il pi
 presto
                     possibile. Ha anche disegnato il logo di Doopsi che
                     appare sullo schermo dell'Editor.
Andrea Rotondo:      per la grafica del Tutorial.
Stefano Clemente:    per il beta-testing.
Lele e Paolo di Intercom: per aver creato la DOOPSI - Mailing list.
Max Galimberti:      per aver controllato questo manuale.
*******
Saluti:
*******
da Andrea a Laura: per avermi sopportato fino ad ora.
da Fabio alla sua mamma (e anche al suo pap
---------------------------------------------------------------------------
********************************
ACCORDO DI LICENZA PER DOOPSI-GS
********************************
I. DIRITTI E RESTRIZIONI DI QUESTA LICENZA
Fabio Rotondo e Andrea Galimberti (gli "autori") vi assicurano
il diritto non-esclusivo, non-assegnabile di usare il software
DOOPSI-GS incluso come eseguibile ("DOOPSI") su di un massimo di 1
computer system alla volta. Non potete effettuare reverse engeneering,
decompilare, o dissassemblare DOOPSI, non rispettare queste restrizioni
e' espressamente proibito dalle leggi vigenti. Non potete prestare o
affittare DOOPSI, o trasferire DOOPSI in altro modo e il materiale
scritto che lo accompagna.
Tutti i diritti non espressamente citati sono riservati dagli autori.
II. NESSUNA GARANZIA
DOOPSI e il materiale scritto che lo accompagna e' fornito "cosi' com'e'",
senza alcuna garanzia di alcun tipo. Per quanto consentito dalla legge,
gli autori scaricano tutte le responsabilita', sia implicite che
esplicite, comprese implicite garanzie di vendibilita', utilita'
per un compito particolare e di non violazione. Gli interi rischi
derivanti dall'uso o dal comportamento di DOOPSI e del materiale
scritto che l'accompagna rimangono a voi.
III. NESSUN OBBLIGO PER DANNI CONSEGUENTI L'USO
Per quanto consentito dalla legge: in alcun caso gli autori o i
loro collaboratori potranno essere accusati per qualsiasi danno
(compresi, senza limitazione, danni per profitti di affari,
interruzione degli affari, perdita di dati commerciali, o qualsiasi
possibilita' di perdita monetaria) derivante dall'uso o dalla
inadeguatezza di usare DOOPSI, persino se gli autori sono stati
avvisati della possibilita' di tali danni. Dal momento che
alcuni stati/giurisdizioni non permettono l'esclusione o la limitazione
di garanzia per danni consequenziali o incidentali, questa limitazione
potrebbe non riguardarvi.
IV. COPIA E DISTRIBUZIONE
Siete autorizzati a distribuire e copiare questo documento con
tutto il resto dell'archivio, solo se il programma e' una versione
"SHAREWARE" o "SPECIAL EDITION". La "SPECIAL EDITION" non puo' essere
distribuita su Aminet o in qualsiasi BBS e non puo' comparire in
alcuna rivista senza il permesso scritto degli autori.
Voi potete, e siete invitati a farlo, copiare e distribuire la versione
originale di DOOPSI SHAREWARE VERSION, ma NON DOVETE COPIARE in qualsiasi
forma la DOOPSI REGISTERED VERSION (versione registrata), eccezion fatta
per l'utilizzo personale.
V. VARIE
Se avete acquistato questo prodotto negli Stati Uniti, questo Accordo e'
soggetto alle leggi dello Stato di Washington. Se avete acquistato
questo prodotto fuori dagli Stati Uniti, verranno applicate le leggi
locali. Se una qualsiasi parte esterna si arroca dei diritti derivanti
dal presente Accordo, la parte prevalente potrebbe essere autorizzata a
richiedere somme di denaro per il risarcimento per l'offesa, i costi e le
spese.
---------------------------------------------------------------------------
**************
Installazione.
**************
 uno script per l'Installer che svolge questo compito, ma per coloro
che desiderassero farlo a mano descriveremo cosa deve essere installato e
dove.  (A proposito:  per usare lo script dovete possedere l'Installer e
l'utility Lha.)
I tre archivi hanno gi
 la struttura finale delle directory.  Dovete prima
estrarre l'archivio Programs.lha; quest'ultimo crea due directory:  una
contiene l'Editor e l'altra contiene il Player.  Vi
 anche una terza
directory in cui potete trovare due librerie:  la "locator.library" e la
famosa "reqtools.library"; dovete copiare queste librerie nella vostra
directory Libs:.  L'ultimo passo consiste nel fare la seguente
assegnazione:  Assign Doopsi: alla directory dell'Editor.
La lingua di default
 l'inglese, ma sono forniti anche i cataloghi per
installare l'italiano:  dovete solo estrarre l'archivio Catalogs.lha nella
stessa directory dove avete messo il cassetto dell'Editor (non NEL cassetto
dell'Editor, ma VICINO a tale cassetto).  Questo crea una directory
Catalogs nel cassetto dell'Editor ed aggiunge anche il file
"player.catalog" nella directory "Editor/Data".
Poi dovete estrarre l'archivio Tutorial.lha nella stessa directory dove
avete messo il cassetto dell'Editor (non NEL cassetto dell'Editor, ma
VICINO a tale cassetto):  questo crea una directory Tutorial nel cassetto
dell'Editor, dove potete trovare un po' di grafica per iniziare
immediatamente.
Per riassumere:  gli archivi son stati costruiti in modo tale che, se li
estraete tutti nella medesima directory, il loro contenuto finir
 nei posti
giusti.
La struttura risultante delle directory
      Editor
      |
      +---Catalogs
      |
      +---Docs
      |
      +---palettes
      |
      +---Data
      |
      `---Tutorial
          |
          +---Objects
          |
          +---Berny
          |
          +---Scenes
          |
          `---Sounds
      Player
L'Editor Deve trovare nella propria directory il file "doopsi.dat".  La
directory Catalogs serve solo se volete usare un linguaggio diverso
dall'inglese (per il momento sono forniti solo i cataloghi italiani):
copiate in tale cassetto solo i cataloghi del vostro linguaggio preferito e
lasciate fuori gli altri.
Il Player Deve trovare nella directory che scegliete mediante l'Editor (si
veda la sezione di questo manuale dedicata alla finestra di Preferenze) i
seguenti file:  "player.dat" e "panel.iff".  Il file "panel.iff"
console che potete cambiare (vedere l'Appendice B).  Il file
"player.catalog"
 necessario solo se volete usare un linguaggio diverso
dall'inglese, altrimenti potete buttarlo via.
I sorgenti dei cataloghi verranno forniti (se si desidera), insieme agli
eseguibili per crearli, in un pacchetto a parte.
NOTA IMPORTANTE:  L'Editor ha bisogno dell'assegnamento Doopsi:, ma il
Player
 stato costruito in modo da essere completamente rilocabile (non
necessita di assegnamenti).  Quando caricate il Player da una Shell dovete
semplicemente far diventare la directory del Player quella corrente e poi
chiamare il programma:  il Player cercher
 quindi la directory che avete
selezionato mediante l'Editor (quella di default
 la directory "Data"
creata dagli archivi), dove Deve trovare i file "player.dat" e "panel.iff".
La linea di comando per caricare il Player
:  Player nome_file_Doopsi.  Se
dimenticate di fornire il nome del file, il Player apre un file requester e
vi chiede di selezionare un file.
---------------------------------------------------------------------------
***********************
La finestra principale.
***********************
La storia inizia da qui.
Prima di tutto, descriviamo i contenuti della finestra.  La parte pi
 alta
 divisa in due sezioni:  quella di sinistra riguarda le scene, mentre
quella di destra
 dedicata agli oggetti.  Poi segue una riga contenente
alcuni editor misti e, infine, la riga finale contiene dei gadget dedicati
al caricamento e salvataggio di tutto il vostro lavoro.
Iniziamo con la sezione delle scene.  Per creare una nuova scena dovete
premere il bottone "Nuovo" e, dopo aver selezionato l'immagine di sfondo
mediante il file requester, vi si chiede di inserire il nome della scena:
questo nome
 l'identificatore che Doopsi usa per indirizzare la scena,
quindi siete invitati a non chiamare due scene con il medesimo nome.  Dopo
che lo sfondo
 stato visualizzato siete pronti per lavorare su questa
scena (per es.:  posizionando degli oggetti su di essa).  Per selezionare
la scena su cui lavorare dovete usare il gadget "Lista":  cliccate sul nome
desiderato nella lista e poi sul bottone "Ok".  Il gadget "Uccidi" serve
per rimuovere la scena corrente.
Quando premete il bottone "Salva" l'editor vi chiede se volete salvare solo
la scena corrente o tutte le scene create fino ad ora.  Con il gadget
"Carica" potete caricare entrambi i tipi di file:  l'Editor riconosce
automaticamente se il file che avete selezionato contiene una o pi
 scene.
Se gli oggetti agganciati alla scena che volete caricare sono gi
 stati
caricati, allora l'editor pu
 posizionarli immediatamente sulla scena
stessa; se invece caricate gli oggetti dopo che la scena
 stata caricata,
allora dovete posizionare tali oggetti a mano, cliccando sul gadget "R"
("R" sta per "ripristina").  Il gadget "Carica" pu
 anche estrarre le
informazioni delle scene da un file salvato con il gadget "Salva Tutto"
posizionato nella fila inferiore della finestra (vedi la descrizione di
tale gadget per informazioni maggiori).
I gadget rimanenti aprono altri editor, e si rimanda alle sezioni del
manuale dedicate a tali editor per informazioni pi
 specifiche.  Il gadget
"Attrs" serve per attivare l'editor degli Attributi delle Scene, dove
potete cambiare alcune caratteristiche della vostra scena; il bottone "Spot
editor" invoca lo Spot Editor per posizionare alcuni Spot sulla scena; il
gadget "Path editor" accede al Path Editor usato per creare il percorso su
cui il vostro Omino dovrebbe camminare.
Ora sapete come creare una nuova scena e siete pronti per posizionarvi
degli oggetti, quindi diamo uno sguardo alla sezione degli oggetti.  Il
gadget "Nuovo" crea un nuovo oggetto ed apre l'editor degli Attributi degli
Oggetti per permettere all'utente di modificare tale oggetto (si veda la
sezione dedicata all'editor degli Attributi per gli Oggetti).  Il gadget
"Lista" visualizza la lista di tutti gli oggetti creati fino ad ora:  per
lavorare su un oggetto dovete renderlo l'oggetto corrente selezionando il
suo nome dalla lista.  Il bottone "Uccidi" rimuove l'oggetto corrente.
Il gadget "Salva" chiede se volete salvare solo l'oggetto corrente o tutti
gli oggetti creati.  Il bottone "Carica" riconosce se il file che avete
selezionato contiene uno o pi
 oggetti e gli aggiunge alla lista.  Questo
bottone pu
 anche estrarre i dati degli oggetti da un file salvato con il
gadget "Salva Tutto".
Il gadget "Attrib" apre l'editor degli Attributi degli Oggetti (quello a
cui accedete automaticamente quando create un nuovo oggetto); il bottone
"Doopsi code" invoca il Doopsi Coder utilizzato per specificare come si
deve comportare il Player quando l'utente agisce su un oggetto; il gadget
"Anim editor" apre l'Anim Editor che vi permette di convertire un oggetto
in un AnimObject costruendo un'animazione a partire dalle sue immagini.
Potete muovere tutti gli oggetti che avete creato e posizionato sulla scena
(utilizzando l'Object Attributes editor) cliccando su di essi con il
bottone sinistro del mouse e (tenendo premuto questo bottone) trascinandoli
all'interno della scena. Cliccando su di essi con il bottone destro del
mouse rendete oggetto corrente l'oggetto selezionato ed invocate l'Object
Attributes editor.
La sezione successiva contiene tre bottoni:  il bottone "Prefs" accede
all'editor delle Preferenze dove potete modificare ad esempio alcuni nomi
che il Player usa come default, o i vostri path preferiti, e cos
 via; il
"Dialog Editor" invoca il Dialog Editor utilizzato per creare dialoghi fra
il vostro Omino e un altro personaggio della vostra storia; il gadget
"Info" vi dice quanti oggetti e scene avete creato fino ad ora e la
quantit
 di memoria disponibile.  Infine il bottone "Prova Gioco" invoca il
Player affinch
 possiate provare immediatamente la vostra avventura:
l'Editor cerca il Player nella directory indicatagli mediante l'apposito
campo situato nella finestra delle Preferenze.
Ora descriviamo l'ultima riga.  Il gadget "Salva Tutto" serve per salvare
tutta l'avventura:  il file contiene scene, oggetti, percorsi, spot,
dialoghi e preferenze, ovvero tutto quello di cui abbisogna il Player per
iniziare il gioco.  Il bottone "Salva Finale" differisce dal gadget "Salva
Tutto" poich
 il file salvato verr
 crittato:  l'Editor vi chiede la chiave
utilizzata per crittare il file.  Abbiamo aggiunto questa opzione poich
questo modo altre persone non possano guardare nel file Doopsi per vedere
come avete costruito la vostra avventura, ma possano comunque giocarci
senza bisogno di conoscere la chiave.  Il gadget "Carica Tutto" vi permette
di caricare un file salvato con il gadget "Salva Tutto" o "Salva Finale",
se volete modificarlo ulteriormente (se il file
 crittato dovete conoscere
la chiave per decrittarlo prima di caricare i dati contenuti).  Il bottone
"Cancella Tutto" serve per cancellare tutto il vostro precedente lavoro e
ricominciare da capo.  Il bottone "Info su Doopsi" visualizza un piccolo
messaggio che dovreste leggere.
I gadget.
Sezione delle scene:
Nuovo             Crea una nuova scena: vi si chiede di selezionare
                  l'immagine di sfondo e di scrivere il nome della scena.
Carica            Carica un file contenente una o pi
 scene.
Salva             Salva un file contenente dati per le scene: vi si chiede
                  se volete salvare solo la scena corrente o tutte le scene
                  create fino ad ora.
Lista             Lista tutte le scene create e vi permette di muovervi fra
                  le scene selezionando quella corrente.
Uccidi            Cancella la scena corrente.
Attrs             Apre lo Scene Attributes editor.
Spot editor       Invoca lo Spot editor.
Path editor       Accede al Path editor.
R                 Ridisegna lo schermo.
Sezione degli oggetti:
Nuovo             Crea un nuovo oggetto ed apre l'Object Attributes editor
                  per poterlo modificare.
Carica            Carica un file contenente uno o pi
 oggetti.
Salva             Salva un file contenente dati per gli oggetti: vi si
                  chiede se volete salvare solo l'oggetto corrente o tutti
                  gli oggetti creati.
Lista             Lista tutti gli oggetti: potete muovervi fra di essi
                  selezionando quello corrente.
Uccidi            Cancella l'oggetto corrente.
Attrib            Apre l'Object Attributes editor.
Doopsi code       Invoca il Doopsi Coder.
Anim editor       Accede all'Anim editor.
Altri gadget:
Prefs             Apre l'editor delle Preferenze.
Dialog editor     Accede al Dialog editor.
Prova Gioco       Invoca il Player.
Info Progetto     Visualizza alcune informazioni sul vostro lavoro.
Carica Tutto      Carica un file contenente tutti i dati del gioco (se il
                  file
 crittato vi viene chiesta la chiave per
                  decrittarlo).
Salva Tutto       Salva un file contenente tutti i dati del gioco, cio
                  file utilizzato dal Player.
Salva Finale      Salva un file crittato contenente tutti i dati del gioco:
                  l'Editor vi chiede la chiave per crittare il file.
Canc. Tutto       Elimina tutto il vostro precedente lavoro.
Info su Doopsi    Alcune note a proposito di noi e di Doopsi.
---------------------------------------------------------------------------
********************************************
Alcune note su come il Player trova l'Omino.
********************************************
Questo problema sorge in quanto l'Omino
 un AnimObject (in realt
 quattro
oggetti:  uno per ogni direzione) come tutti gli altri AnimObject che
potete agganciare al vostro gioco.  Quindi il Player deve sapere quali
oggetti rappresentano il protagonista della storia.  Il nome interno
dell'Omino
 composto da una radice (quella di default
 "Omino") ed una
estensione che indica la direzione (ad es.:  A per alto, G per gi
, ecc.):
quindi l'AnimObject contenente l'animazione che rappresenta l'Omino che
cammina verso destra potrebbe essere chiamata (sempre nome interno!)
"OminoD", e cos
 via.  Avete bisogno anche di altri quattro AnimObject
rappresentanti l'Omino che parla nelle quattro direzioni:  il nome di tali
AnimObject
 costruito a partire dalla radice, aggiungendo ad essa una
prima estensione (quella di default
 "Parla") e la seconda estensione
direzione, come prima.  Quindi un nome tipico per l'AnimObject
rappresentante l'Omino che parla verso sinistra
 "OminoParlaS".
Potete scegliere la radice e le estensioni che preferite scrivendole
nell'editor delle preferenze.
Un'ultima nota a proposito di estensioni.  Il Doopsi Coder contiene
istruzioni utilizzate per muovere (e/o animare) oggetti sulla scena durante
il gioco:  vi si chiede di fornire il nome dell'AnimObject contenente
l'animazione desiderata.  E qui arriva la parte interessante:  se tale nome
termina con una delle quattro estensioni indicanti una direzione, allora il
Player
 autorizzato a scegliere la direzione che gli serve.  Fa ci
rimuovendo l'estensione e rimpiazzandola con quella indicante la direzione
giusta, poi cerca un AnimObject con il nome risultante dall'operazione
precedente e, se lo trova, lo usa.  Per esempio:  se il nome che avete
selezionato come argomento per l'istruzione SetMoveAnim
 "VolaD" e la
mosca si deve muovere verso l'alto, allora il Player cerca un AnimObject
chiamato "VolaA".  In altre parole:  l'estensione che voi fornite al
momento della programmazione
 irrilevante perch
 verr
 rimpiazzata prima
di essere utilizzata, ma essa dice al Player di stare attento alla
direzione.  Per sapere quali istruzioni hanno questa opzione consultate
l'Appendice A.
Osservazioni generali che dovreste leggere:
L'Editor produce un file contenente la struttura della vostra avventura, ma
non la grafica o i suoni che avete agganciato al gioco poich
 non vogliamo
mescolare tutta l'avventura in un solo file enorme; quindi nel file
generato vi sono solo i percorsi dei file agganciati.  Dovete ricordarvi di
questo particolare se volete distribuire il vostro gioco agli amici:  per
esempio, potete far diventare relativi i percorsi utilizzando
un'assegnamento.
---------------------------------------------------------------------------
************
Path Editor.
************
Introduzione.
Il Path Editor si occupa di aiutare il creatore dell'avventura a sviluppare
i percorsi nei quali si muoveranno i vari personaggi.  La creazione dei
percorsi
 forse una delle cose pi
 complesse e richiede una certa
attenzione.  A ben vedere, il percorso che verr
 creato su di una scena
vincoler
 i movimenti dei personaggi durante il gioco.  Questo deve
necessariamente portare ad una pianificazione ponderata per la creazione
del percorso.
Teoria dei path.
Il percoso, o path,
 strutturato in nodi, delle unit
 di sosta.  Ogni nodo
 avere delle caratteristiche particolari che permettono un maggiore
controllo del movimento del personaggio sulla scena.  Di queste
caratteristiche parleremo pi
 avanti.  Ogni nodo ha dei "rami" (branch) al
massimo sette per ogni nodo, che permettono di collegarsi ad altri nodi.
Il path determina, attraverso i nodi, la possibilit
 di movimento del
personaggio sulla scena.  Un percorso
 quindi formato da nodi, uniti tra
loro da collegamenti (branch), in modo da formare una specie di "rete".  I
movimenti del personaggio dell'avventura sulla scena avverr
 appunto su
questa rete, come se i nodi con le loro diramazioni fossero una specie di
"binario invisibile" sul quale il personaggio si muove.  Non
 possibile,
in alcun modo, muovere il personaggio in zone della scena non raggiungibili
da un nodo.  Se si chiede al personaggio di muoversi in un luogo esterno
alla diramazione del percorso, verr
 raggiunto il punto ritenuto pi
 vicino
a quello richiesto, ma non si andr
 oltre.  Questo aspetto dei path pu
sembrare una limitazione, ma
 in realt
 una delle caratteristiche che
assicurano una grandissima flessibilit
 a livello di game-design:  per
esempio,
 possibile creare una scena che racchiude pi
 percorsi e
"vietare" l'accesso a certe aree a meno che non si siano verificate
determinate condizioni.
Con un po' di pratica, riuscirete sicuramente a creare dei percorsi
complessi ed articolati.  Il Path Editor vi assister
 costantemente e con
affidabilit
 in questo compito.  Buon lavoro.
NOTA:  I seguenti tutorial presuppongono che voi conosciate gi
 altre
caratteristiche proprie di Doopsi, quali la creazione di nuove scene, la
creazione di animazioni tramite AnimWorkshop e la gestione degli oggetti
tramite l'editor di Attributi dell'Oggetto.
Tutorial 1 - Un Semplice Percorso
In questo tutorial impareremo a disegnare un piccolo percorso di quattro
nodi e ad unire questi nodi tra loro con delle semplici diramazioni.  Scopo
di questo tutorial
 di impratichirvi con i comandi di base del Path
Editor.  Imparerete ad aggiungere e cancellare nodi, ad aggiungere
collegamenti e a forzare il ridisegnamento di tutta la scena (necessario in
alcuni casi).  Nel prossimo tutorial costruiremo qualcosa di pi
 complesso.
Eseguite questa esercitazione anche pi
 volte, fino a quando non sarete
certi di avere completa padronanza dei comandi.
Per eseguire questo tutorial dovrete aver creato prima una scena con
l'immagine "tutorial_room1".
Premete Path Editor nel pannello principale di Doopsi.
Non fatevi spaventare dal numero di pulsanti che ci sono, col tempo ne
avrete piena padronanza.
Prima di tutto,
 consigliabile sistemare tutti i nodi che si desiderano
sullo schermo.  Naturalmente
 possibile aggiungerne anche in seguito, ma
in questo modo sarete certi di coprire almeno tutti i punti importanti.
Per aggiungere un nodo sulla scena
 sufficiente eseguire questi passaggi:
   - Premete "Agg. Nodi"
     Da questo momento in poi, fino a quando non decideremo di smettere,
     ogni click del mouse sulla scena dar
 origine alla creazione dei nodi.
   - Create quattro nodi in modo che formino una specie di quadrato.
   - Premete "Agg. Coll." per aggiungere i collegamenti.
     Da questo momento in poi, fino a quando non decideremo interrompere
     l'operazione, potremo aggiungere collegamenti tra i nodi.
   - Premete sul primo nodo (il nodo cambier
 di colore)
   - Premete sul secondo nodo (il nodo cambier
 di colore e una linea unir
     i due nodi)
   Abbiamo appena creato il primo collegamento.  Per creare il secondo,
   procediamo in questo ordine:
   - Premete sul secondo nodo (il nodo cambier
 colore)
   - Premete sul terzo nodo (il nodo cambier
 colore e una linea unir
     due nodi)
   Proseguite in questo modo fino a quando non avrete creato un vero
   "quadrato".
Adesso che avete creato questi nodi, potete testare lo spostamento che
effettuer
 il personaggio durante l'avventura:
   - premete il bottone "Prova Movim." e selezionate il nodo di partenza
     (per esempio il primo).  Il nodo si illuminer
   - Selezionate il secondo nodo (ad esempio il terzo).  Il nodo si
     illuminer
Il programma cercher
 di calcolare un percorso tra i due nodi selezionati e
lo visualizzer
, passo passo, illuminando i nodi.  Se avete selezionato il
primo ed il terzo e li avete collegati come descritto nel nostro esempio,
dovreste vedere illuminarsi i nodi uno, due e tre.  Naturalmente questo
un esempio semplice, ma la possibilit
 di provare il path si rivela molto
utile in scene complesse.
Adesso create un nuovo nodo dove volete e collegategli altri nodi, seguendo
i procedimenti appena descritti.  Riprovate ad utilizzare "Prova Movim.".
Prima di terminare il tutorial, proviamo a rimuovere un nodo dalla scena:
   - Premete "Uccidi Nodo"
   - Selezionate il nodo che intendete cancellare.
   - Il nodo verr
 cancellato.
A questo punto,
 possibile che della grafica sulla scena sia rovinata e
che il nodo appena cancellato compaia ancora.  Questo non
 un errore di
Doopsi, ma
 necessario eseguire un aggiornamento della grafica (refresh).
Premete "Aggiorna" per aggiornare la grafica, vedrete che adesso il nodo
cancellato non comaprir
Tutorial 2 - La programmazione dei nodi
I percorsi sono strumenti potentissimi.  Per utilizzarli al meglio
necessario provare e riprovare.  Quello che cercheremo di spiegarvi adesso
 la "programmazione" di un nodo.
Un nodo puo' essere programmato per le seguenti attivit
   - Modificare l'animazione del personaggio
   - Modificare la priorit
 uomo/oggetti
   - Determinare il cambio di scena
   - Controllare se un nodo
 percorribile (controllo di condizione)
Tutte queste operazioni sono complesse da realizzare e richiedono uno
strudio accurato della generazione del percorso.
Vediamo adesso come
 possibile programmare un nodo e quali sono le
condizioni da tenere in considerazione nella progettazione di un percorso.
Per programmare un nodo,
 sufficiente premere il bottone "Codice" nel Path
Editor e poi selezionare il nodo che si intende modificare.
   - Modificare l'animazione del personaggio
     Premere il bottone "Setta Anim.", apparir
 un Lister con tutti gli
     oggetti (animati e non) presenti nell'avventura. Selezionate quello
     che vi riguarda (Deve essere un AnimObject).
   - Modificare la priorit
 uomo/oggetti
     Premete il bottone "Cambia Pri", verranno alternate le scritte "Uomo
     Su Oggetti" o "Oggetti Su Uomo".
   - Determinare il cambio di scena
     Premere su "Set Start", apparir
 un Lister contenente tutte le scene
     create. Selezionate quella nella quale desiderate spostarvi quando il
     personaggio passer
 sopra al nodo.
   - Controllare se un nodo
 percorribile (controllo di condizione)
     Premete "Set Condizione", apparir
 un Lister con tutti i nomi degli
     oggetti presenti nell'avventura. Selezionato l'oggetto, comparir
     uno status requester per determinare la condizione che andr
     controllata su quel determinato nodo.
Facciamo un piccolissimo esempio di utilizzo:
Immaginate di avere i seguenti nodi:
    1 ---- 2 ---- 3 ---- 4 ---- 5
Noi vogliamo che il nodo 5 ci faccia saltare alla scena "Ufficio", ma solo
quando l'oggetto "porta"
 aperta (supponiamo che lo status sia a 1 quando
la pora
 aperta).  Dobbiamo fare in modo che il protagonista NON possa
raggiungere il nodo n.5 se non quando la porta
 aperta.
Iniziamo a programmare il nodo 5.  Premete "Codice" e poi sul nodo 5, e
cliccate su "Set Start", selezionando la scena "Ufficio":  da ora in poi
tutte le volte che il personaggio arriver
 sul nodo n.5, passer
 alla scena
"Ufficio".
Ora programmate il nodo n.4:  premete "Codice" poi selezionate il nodo e
cliccate su "Set Condizione".  Premete sull'oggetto "Porta" e inserite come
valore di status 1.  Fatto!  Adesso, se la porta
 chiusa, il nodo n.5 non
 raggiungibile.
Descrizione generale.
Probabilmente questo
 l'editor con pi
 bottoni, ma questi gadget sono
raccolti in gruppi.  Esamineremo un gruppo alla volta.
Il primo gruppo che mi accingo a descrivere
 quello situato nell'angolo in
alto a sinistra della finestra.  Il bottone "Agg.  Nodi" attiva l'aggiunta
dei nodi, cio
, dopo aver premuto questo gadget potete aggiungere quanti
nodi volete fino a quando siete soddisfatti:  dovete solo cliccare sulla
scena nel punto dove volete un nodo.  Per uscire dall'aggiunta dei nodi
dovete premere ancora il gadget "Agg.  Nodi" (o un altro gadget del
medesimo gruppo).  Il bottone "Uccidi Nodo" vi chiede di selezionare il
nodo da uccidere, dopo di che l'Editor lo rimuover
 dalla scena:  il nodo
"morto" lascer
 un quadrato nero sulla scena, cos
, se volete restaurare la
vostra grafica, dovete premere il bottone "Aggiorna".  Il bottone
"Aggiorna" ridisegna tutta la grafica contenuta nella scena corrente.  Il
bottone "Agg.  Coll." serve per attivare l'aggiunta dei collegamenti:  per
aggiungere un collegamento fra due nodi premete prima sul nodo iniziale e
poi su quello finale.  Potete ripetere questi passaggi fino a quando non
avrete finito di collegare tutti i vostri nodi; quindi premete il bottone
"Agg.  Coll." ancora una volta per uscire dall'aggiunta dei collegamenti.
Il gadget "Codice" vi chiede di selezionare il nodo da programmare; per
terminare la sessione di programmazione premete ancora sul bottone
"Codice":  l'Editor vi chieder
 di selezionare un'altro nodo da
programmare, ma potete cliccare nel campo del "Messaggio" per farlo
smettere definitivamente.
La programmazione dei nodi ci porta direttamente al gruppo intitolato
"Modifica Settaggi".  Il bottone "Setta Anim."
 utilizzato per cambiare le
animazioni dell'Omino quando l'Omino passa su quel nodo:  l'Editor apre un
lister con tutti i nomi degli oggetti creati ed aspetta che l'utente
selezioni un nome dalla lista.  A questo punto il testo "Default" alla
sinistra del gadget viene rimpiazzato con il nome scelto.  Da questo nodo
in poi il Player user
 la radice del nome scelto come radice per costruire
tutti i nomi delle animazioni dell'Omino (se questo non vi dice niente
allora dovreste leggere le "Alcune note su come il Player trova l'Omino"
situate appena dopo la sezione della Finestra Principale di questo
manuale).  Il gadget "Cambia Pri." alterna la priorit
 fra "Uomo Su
Oggetti" a "Oggetti Su Uomo" e viceversa:  la prima condizione significa
che l'Omino apparir
 davanti a tutti gli oggetti mentre cammina verso quel
nodo, la seconda significa giusto il contrario (potete trovare altre note a
proposito di come questo funzioni nella sezione dedicata al Player del
manuale).  Il bottone "Set Start" apre un lister con i nomi di tutte le
scene create fino ad ora:  il nome della scena selezionata apparir
 alla
sinistra del gadget nel campo "Start".  Se questo campo non
 vuoto il
Player, quando l'Omino calpesta quel nodo, cerca una scena avente il nome
scelto; se la scena viene trovata allora il Player abbandona la scena
precedente ed entra in quella nuova.  Nella nuova scena l'Omino verr
posizionato sul nodo contenente (nel campo "Start") il nome della scena da
cui l'Omino proviene.  (E' come se il nodo "finale" della prima scena punti
verso il nodo "iniziale" della seconda, e viceversa.)
Il prossimo gruppo
 quello chiamato "Condizioni".  Il bottone "Set
Condizione" permette all'utente di arrestare l'Omino se una determinata
condizione non
 verificata:  la condizione
 del tipo "Se lo stato
dell'oggetto
 uguale a".  Il bottone apre un lister con i nomi degli
oggetti; dopo aver selezionato un oggetto dovete inserire il valore dello
stato che volete controllare.  Se il campo di Stato dell'oggetto
selezionato non contiene il valore scelto quando l'Omino cammina su quel
nodo, allora all'Omino non
 permesso oltrepassare tale nodo.  Il gadget
"Cancella Condiz." cancella i campi di condizione del nodo.
Il bottone "Prova Movim." vi permette di vedere come l'Omino camminer
vostro percorso:  vi si chiede di selezionare il nodo di partenza ed il
nodo di arrivo; a questo punto l'Editor illuminer
 i nodi su cui l'Omino
passer
 mentre va dal nodo iniziale a quello finale.  Il bottone "Controlla
Nodi" controlla se tutti i nodi sono correttamente collegati e rimuove i
nodi isolati.
Ci mancano solo tre gadget.  Il bottone "Nuovo Path" cancella completamente
il path attuale.  Il gadget "Salva Path" salva il path corrente in un file,
e il gadget "Carica Path" carica un file salvato con il precedente bottone.
Alcuni suggerimenti utili:
Premete sempre il bottone "Controlla Nodi" prima di salvare tutto il vostro
lavoro, poich
 in questo modo vi eviterete sgradite sorprese.
Quando posizionate i nodi non dimenticatevi delle dimensioni dell'Omino:
l'hot spot dell'Omino
 posizionato nell'angolo in basso a sinistra
dell'immagine dell'Omino, quindi l'Omino si ferma sempre alla destra di un
nodo.  Questo implica che l'Omino pu
 raggiungere il bordo destro (o il
bordo superiore) della scena prima di raggiungere il nodo di destinazione
se posizionate tale nodo troppo vicino al bordo della scena:  quando
l'Omino raggiunge il bordo della scena si ferma, cos
 il vostro nodo non
 mai raggiunto.
Quando stabilite la priorit
 dell'Omino sugli oggetti tenete presente le
dimensioni dell'Omino:  se un nodo dice "Oggetti Su Uomo" ed il seguente
dice "Uomo Su Oggetti" e l'Omino, andando dal primo al secondo nodo,
ancora parzialmente coperto da un oggetto, esso pu
 venire improvvisamente
posizionato davanti all'oggetto che lo copre.  Di conseguenza vi capiter
spesso di dover scegliere la priorit
 "Oggetti su Uomo" anche per un nodo
che non
 coperto da alcun oggetto per essere sicuri che l'Omino sia
completamente scoperto prima di cambiare la sua priorit
I gadget.
Agg. Nodi         Attiva l'aggiunta dei nodi: cliccate sulla scena per
                  posizionare quanti nodi volete, e poi cliccate su questo
                  gadget per uscire dall'aggiunta.
Uccidi Nodo       Chiede di selezionare un nodo e poi lo cancella. Cliccate
                  ancora su questo bottone per annullare l'operazione.
Agg. Coll.        Attiva l'aggiunta dei collegamenti: cliccate sul nodo
                  iniziale e su quello finale fino a quando non avrete
                  posizionato tutti i colegamenti. Premete ancora questo
                  gadget per uscire dall'aggiunta.
Codice            Attiva la sessione di programmazione. Quando avete finito
                  di cambiare gli attributi del nodo premete ancora questo
                  bottone.
Aggiorna          Ridisegna tutta la grafica della scena.
Setta Anim.       Cambia il campo "Anim" del nodo.
Cambia Pri        Cambia la priorit
 dell'Omino rispetto agli oggetti.
Set Start         Seleziona la scena in cui entrare quando l'Omino cammina
                  su questo nodo.
Set Condizione    Stabilisce la condizione che deve essere verificata
                  affinch
 l'Omino possa oltrepassare il nodo.
Cancella Condiz.  Cancella il campi di condizione di un nodo.
Nuovo Path        Cancella il path corrente.
Salva Path        Salva il path corrente in un file.
Carica Path       Carica un path da un file.
---------------------------------------------------------------------------
************
Spot Editor.
************
Questo vi permette di posizionare degli "Spot" sulla scena:  essi sono
semplicemente delle piccole crocette con due coordinate ed un nome.  Voi
usate questo nome per designare un particolare spot e Doopsi user
 le sue
coordinate.  Gli spot vengono usati assieme, ad esempio, all'istruzione
MoveObject per indicare il posto dove l'oggetto dovr
 recarsi.
Eccovi un TUTORIAL:
- Create una nuova scena (utilizzando il bottone "New" nella sezione
dedicata alle scene della finestra principale dell'editor).
- Attivate lo Spot editor.
- Selezionate il gadget "Aggiungi Spot":  apparir
 il messaggio "Aggiungi
gli spot".
- Cliccate sulla scena dove volete mettere uno spot:  potete ripetere
questa operazione fino a quando avrete posizionato tutti i vostri spot.
- Selezionate ancora il bottone "Aggiungi Spot" per disattivare il modo di
aggiunta degli spot.
- Cliccate sulla scena per selezionare uno spot:  apparir
 il messaggio
"Informazioni".
- Potete modificare il nome dello spot corrente semplicemente scrivendolo
nello string gadget "Nome Spot" e premendo Return.
- Uscite dallo Spot editor.
Descrizione generale.
Per aggiungere alcuni spot dovete cliccare sul bottone "Aggiungi Spot":
quindi cliccate sulla scena ovunque vogliate posizionare uno spot.  Poich
uno spot senza un nome non ha senso lo Spot Editor attribuisce ai vostri
spot un nome di default, nome che potete cambiare in ogni momento
semplicemente riscrivendolo nel gadget stringa chiamato "Nome Spot" e
premendo Return.  D'ora in poi potete aggiungere spot a vostro piacimento.
Quando siete soddisfatti, potete interrompere l'aggiunta di spot premendo
ancora il bottone sinistro del mouse sul gadget "Aggiungi Spot" o su quello
chiamato "Elimina Spot" o, infine, su qualunque parte della finestra
dell'editor.  Per eliminare uno spot premete una volta il gadget "Elimina
Spot":  l'editor vi chieder
 di scegliere lo spot da uccidere, e quindi non
vi rimane che cliccare su tale spot.  Questo
 tutto.  A proposito, dopo
aver ucciso uno spot (o dopo aver deciso di non ucciderlo cliccando ancora
nella finestra dell'editor)
 necessario riselezionare il gadget "Elimina
Spot" per ucciderne un'altro, e cos
 via.
L'azione di default (quando non state aggiungendo o eliminando spot)
chiamata "Informazioni":  siete liberi di cliccare su qualunque spot per
illuminarlo e visualizzare il suo nome nello string gadget.  Come ho detto
in precedenza, questo nome pu
 essere modificato ogni volta che viene
visualizzato.
Manca ancora un gadget:  il bottone "Aggiorna".  Dopo aver posizionato (ed
eliminato) molti spot la vostra scena potrebbe apparire un po' sottosopra:
cliccate su questo gadget e Doopsi pulir
 la stanza per voi.
I gadget:
Aggiungi Spot     Attiva (e disattiva) l'aggiunta degli spot.
Elimina Spot      Cancella uno spot.
Nome Spot         Modifica il nome dello spot.
Aggiorna          Ridisegna la scena.
---------------------------------------------------------------------------
*************************
Screen Attributes editor.
*************************
Questo editor vi permette di cambiare il nome della scena corrente, di
caricare uno sfondo diverso senza rimuovere oggetti, percorso e spot che
avete gi
 agganciato a quella scena, ed altre cose utili...
L'ultima riga in basso dice qualcosa del genere:  "Usa Azione Apri di
Oggetto pippo".  In altre parole il codice Doopsi contenuto nell'azione
specificata dell'oggetto selezionato verr
 eseguito tutte le volte che
entrerete nella scena durante il gioco.  Per disattivare questa opzione
dovete cancellare il nome dell'oggetto nello string gadget.  Un
suggerimento utile:  se volete che il codice sia eseguito solo la prima
volta in cui entrate nella scena (o in occasioni speciali) potete sfruttare
il campo di stato dell'oggetto:  inserite in questo campo un valore
particolare ed iniziate il codice Doopsi con l'istruzione "IfStatus".
I gadget:
Cambia Sfondo     Carica un nuovo sfondo per la scena. Se almeno un nodo
                  del percorso esistente o uno spot cadono al di fuori
                  della bitmap allora l'editor vi avviser
 senza, per
                  rimuovere l'oggetto incriminato.
Nome Scena        Cambia il nome interno della scena.
Nome Musica       Potete inserire il nome di un modulo che verr
 suonato
                  ogni volta che entrerete nella scena (durante il gioco,
                  ovviamente) e verr
 interrotto quando uscirete dalla
                  scena stessa. Potete cliccare sul bottone per aprire un
                  file requester e selezionare il modulo, oppure potete
                  scriverne direttamente il nome nel gadget stringa.
Usa Azione        Questo cycle gadget vi permette di scegliere l'azione da
                  cui leggere il codice Doopsi che
 eseguito quando
                  entrate nella scena durante il gioco.
di Oggetto        Seleziona l'oggetto da cui leggere il codice Doopsi
                  specificato dal gadget "Usa Azione". Questo bottone apre
                  una lista con i nomi di tutti gli oggetti. Potete anche
                  inserire il nome dell'oggetto a mano utilizzando il
                  gadget stringa.
---------------------------------------------------------------------------
***************************************
L'Editor degli Attributi di un Oggetto.
***************************************
Questo editor vi permette di specificare le caratteristiche di un oggetto e
di posizionarlo sulla scena.
Un primo tutorial: "il foglietto".
- Suppongo che abbiate gi
 caricato una scena per potervi posizionare degli
oggetti.  Ora create un nuovo oggetto premendo il bottone "Nuovo" nella
sezione dedicata agli oggetti della finestra principale.
- Attivate l'editor degli Attributi.
- Nel gadget "Nome" scrivete "il foglietto".
- Cliccate sul gadget "Nome Interno" e scrivete "foglietto".
- Cliccate sul cycle gadget per selezionare "Grafica" come tipo di oggetto,
in quanto il nostro oggetto dovr
 essere disegnato sulla scena.
- Premete il bottone "Agg." e, usando il file requester, scegliere
l'immagine "paper" nella directory Tutorial.  Ora l'immagine
 agganciata
all'oggetto.
- Infine premete il bottone "Pos" per posizionare l'oggetto sulla scena.
- Potete muovere l'oggetto nella sua posizione finale selezionandolo con il
mouse e trascinandolo all'interno della scena.
Un secondo tutorial: "una zona vuota".
- Create un nuovo oggetto come nel precedente tutorial.
- Scrivete il suo nome e (pi
 importante) il suo nome interno.
- Cliccate sul cycle gadget per selezionare "Vuota" come tipo di oggetto:
il nostro oggetto sar
 una cornice vuota (che non verr
 disegnata sullo
schermo durante il gioco).
- Premete il bottone "Setta Zona": un rettangolo apparir
 sulla scena.
- Trascinate il rettangolo nella scena con il mouse e scalatelo utilizzando
il gadget posizionato nell'angolo in basso a destra del rettangolo stesso.
- Quando avete finito premete il gadget "Pos" per agganciare questo oggetto
alla scena.
Descrizione generale.
Potete attivare questo editor cliccando sul bottone "Attrib" nella sezione
dedicata agli oggetti della finestra principale o cliccando il tasto destro
del mouse su un oggetto gi
 posizionato sullo schermo.
I primi campi che dovete riempire sono quelli indicati con "Nome" e "Nome
Interno":  il nome di un oggetto
 la stringa che appare sulla linea di
testo della console del Player quando il puntatore
 su tale oggetto; il
nome interno
 l'identificatore che Doopsi usa per indirizzare un oggetto:
per questa ragione siete invitati a non usare pi
 volte lo stesso nome.
Dopodich
 concentriamoci sulla zona delle immagini.  Per aggiungere alcune
immagini al vostro oggetto dovete cliccare sul bottone "Agg.":  l'editor
aprir
 un file requester e, dopo che avrete selezionato un file valido,
visualizzer
 il nome dell'immagine (completa di percorso) nella lista.  Per
eliminare un'immagine non dovete far altro che cliccare su tale immagine e
poi premere il bottone "Uccidi".  Poi dovete dire all'editor quale immagine
usare per disegnare l'oggetto sulla scena; per far ci
 selezionate una
immagine nella lista a premete il gadget "Shp Def.":  apparir
 un numero
che mostra qual
 l'immagine corrente.  Una procedura simile
 necessaria
per dire al Player qual
 l'immagine di inventario:  cliccate su
un'immagine e poi sul bottone "Shp Inv.".  A proposito:  le immagini di
inventario devono avere dimensioni di 32*32 pixel, altrimenti verranno
tagliate prima di essere visualizzate dal Player.  Vi
 ancora un gadget da
descrivere:  il cycle gadget
 necessario per scegliere se si vuole un
oggetto "Grafico" od uno "Vuoto".  Il primo ha un'immagine corrente che
viene disegnata sulla scena, mentre il secondo
 solo un rettangolo vuoto
utilizzato per incorniciare qualcosa appartenente allo sfondo.  Per
posizionare e ridimensionare tale rettangolo dovete cliccare sul bottone
"Setta Zona":  una Zona Vuota verr
 disegnata sulla scena, zona che potete
trascinare col mouse cliccando su di essa; per riscalarla premete
semplicemente sul quadrato pieno nell'angolo in basso a destra della zona
stessa.  E' importante notare che anche oggetti Vuoti possono avere alcune
immagini agganciate:  potete usare queste immagini con i comandi del Player
che riguardano l'inventario.  Ciascun oggetto ha spazio per pi
 di una
immagine e pi
 di una immagine di inventario poich
 durante il gioco potete
cambiare l'immagine corrente dell'oggetto o la sua immagine di inventario
utilizzando le istruzioni del Player relative alle immagini.
Nel gadget "Stato" potete inserire il valore di partenza dello stato
dell'oggetto.  Il campo di stato
 un valore intero privo di un significato
particolare, dimodoch
 lo potete usare per qualunque scopo vi aggradi, ad
es.:  potete memorizzare qui lo stato Aperto/Chiuso di una porta scrivendo
0 per Chiuso e 1 per Aperto, e potete cambiare questo stato durante il
gioco usando ChangeStatus ed altre istruzioni del Player.
Uscendo da questo editor ricordate di premere sempre il bottone "Pos" se
volete agganciare l'oggetto alla scena, anche se l'avete gi
 fatto in
precedenza:  questo perch
 il gadget "Ok" accetta le modifiche apportate
all'oggetto ma sgancia sempre tale oggetto dalla scena.  Non c'
 bisogno di
spiegare cosa fa il gadget "Cancella".
I gadget:
Nome           Nome dell'oggetto.
Nome Interno   Nome interno dell'oggetto.
Shp Def.       Questo intero punta all'immagine utilizzata per disegnare
               l'oggetto sulla scena. Non ha significato alcuno per una
               Zona Vuota.
Shp Inv.       Questo intero punta all'immagine utilizzata dal Player per
               immagazzinare l'oggetto nell'inventario (le dimensioni di
               questa immagine devono essere di 32*32 pixel).
Vuota/Grafica  Seleziona il tipo di oggetto.
Agg.           Aggancia un'immagine all'oggetto e aggiunge il suo nome alla
               lista.
Uccidi         Rimuove un'immagine dalla lista.
Stato          Modifica il valore corrente dello stato.
Setta Zona     Crea il rettangolo di una Zona Vuota.
Pos            Esce agganciando l'oggetto alla scena.
Ok             Esce senza agganciare l'oggetto alla scena (se l'oggetto
               gi
 agganciato, allora questo gadget lo sgancia).
Cancella       Esce ripristinando le condizioni iniziali.
---------------------------------------------------------------------------
*************
Doopsi Coder.
*************
Introduzione.
Doopsi Coder
 l'editor che vi permette di "programmare" gli oggetti a
reagire alle azioni dell'utente.  Per il player di DOOPSI, gli oggetti non
sono altro che complesse strutture di dati senza per
 alcun vero
significato.  Compito del Coder
 di permettere un coordinamento tra le
azioni possibili dal giocatore e il comportamento di ogni oggetto.  Il
Coder
 forse la parte pi
 importante nell'editing di una avventura, in
quanto permette effettivamente al creatore della storia di dare una forma
"reale" agli oggetti in scena e di permettere al giocatore di interagire
con gli oggetti stessi.
La teoria che
 alla base del Doopsi Coder
 molto semplice:  ad ogni
azione permessa all'utente potrebbe corrispondere una reazione da parte
dell'oggetto interessato.  Abbiamo detto "potrebbe" perch
 non
 necessario
che ogni oggetto sia in grado di rispondere a tutte le azioni che l'utente
desidererebbe effettuare.  Se ad esempio il giocatore volesse parlare con
la porta, quest'ultima non
 tenuta a rispondere (a meno che non si tratti
di una porta magica...)
La programmazione degli oggetti in Doopsi avviene all'interno del Coder,
che garantisce un ambiente semplice e rapido per la loro organizzazione.
Non preoccupatevi se non avete dimestichezza con la programmazione:  non
dovrete scrivere neppure una linea di codice, in quanto il Coder rende
questo compito accessibile a chiunque:  tutto quello che dovrete fare
avere bene in mente quello che desiderate ottenere da una determinata
azione su di uno specifico oggetto.
Nozioni generali di OOP in Doopsi.
Doopsi significa "Dynamic Object Oriented Programming System Interface",
Interfaccia di Sistema per la Programmazione Dinamica Orientata agli
Oggetti.  I programmatori smaliziati noteranno che in Doopsi non
presente un vero e proprio interprete OOP, bens
 Doopsi stesso che si
occupa di gestire l'interfacciamento oggetto-codice.  Per questo la
programmazione OOP in Doopsi
 Dinamica:  gli oggetti possono mutare forma
e caratteristiche "al volo".  Gli oggetti sono visti come delle "entit
un insieme di dati e caratteristiche che li rendono unici e riconoscibili.
Tutti i dati contenuti all'interno di un oggetto sono protetti e non
direttamente accessibili.  L'accesso
 garantito solo tramite le istruzioni
del Doopsi Language che si occupa di "smistare" i comandi e di accedere
correttamente ai dati desiderati.  Molti comandi chiedono come primo
parametro il nome interno dell'oggetto sul quale dovranno agire.  Questo
significa che il codice di un oggetto pu
 modificare le caratteristiche di
un altro oggetto del gioco.  Ogni oggetto possiede uno "Status", un valore
che pu
 essere modificato con del codice Doopsi e che rappresenta quello
che il programmatore desidera:  il valore di Status
 arbitrario e non
legato all'oggetto, dipende al programmatore definire come utilizzare
Status.
I comandi del Doopsi-Language sono elencati completamente nell'Appendice A.
NOTA:  i seguenti tutorial presuppongono che voi abbiate padronanza di
altre parti di Doopsi, come l'Editor degli Attributi dell'Oggetto.  Vedere
i Tutorial del capitolo "Creazione di Oggetti" se non si hanno ben chiari i
principi della creazione degli oggetti.
Tutorial 1 - Una porta che si apre e si chiude
Questo esempio presuppone che abbiate gi
 creato un oggetto chiamato
internamente "door" che possiede due immagini, la prima raffigurante la
porta chiusa ("door_closed") e la seconda raffigurante la porta aperta
("door_open").
- Dall'editor principale, selezionate l'oggetto "door" come corrente e
premete il bottone Doopsi Coder, sarete cos
 pronti a programmare
l'oggetto.
- Premete il bottone "Apri" per programmare la reazione dell'oggetto
"door" all'azione "Apri".  Eseguite questi passi:
    - Comando "IfStatus"
    - Selezionate l'oggetto "door"
    - Inserite 0 come valore
    (Nella finestra del Coder comparir
 il comando: IfStatus SELF, 00)
    - Comando "ChangeStatus"
    - Selezionate l'oggetto "door"
    - Inserite 1 come valore
    (Nella finestra del Coder comparir
 il comando: ChangeStatus SELF, 01)
    - Comando "ChangeShape"
    - Selezionate l'oggetto "door"
    - Selezionate l'immagine raffigurante la porta aperta (ad es. "door_open")
    (Nella finestra del Coder comparir
 il comando: ChangeShape SELF, 01)
    - Comando "Else"
    - Comando "ShowText"
    - Inserite "La porta
 aperta"
    (Nella finestra del Coder comparir
 il comando:  ShowText La port
   aperta)
   - Comando "EndIf"
Al termine della sequenza appenna effettuata, nella finestra del Coder
comparir
 questo codice:
    IfStatus SELF, 00
    ChangeStatus SELF, 01
    ChangeShape SELF, 01
    Else
    ShowText La porta
 aperta
    EndIf
Questo codice significa (spiegato riga per riga):
    Se lo status dell'oggetto stesso (SELF, la porta)
    Cambia lo status dell'oggetto stesso (SELF, la porta) a 1
    Cambia l'immagine dell'oggetto stesso (sempre la porta) a 1 ("door_open")
    Altrimenti (Else)
    Mostra il Messaggio "La porta
 aperta"
    Fine del controllo.
Scriviamo adesso il codice necessario per l'azione "Chiudi".  Premete il
bottone "Chiudi" per programmare la risposta dell'oggetto porta all'azione
di chiusura.  Eseguite questi passi:
    - Comando "IfStatus"
    - Selezionate l'oggetto "door"
    - Inserite il valore 1
    - Comando "ChangeStatus"
    - Selezionate l'oggetto "door"
    - Inserite il valore 0
    - Comando "ChangeShape"
    - Selezionate l'oggetto "door"
    - Selezionate l'immagine "door_closed"
    - Comando "Else"
    - Comando "ShowText"
    - Inserite "La porta
 chiusa"
    - Comando "EndIf"
Comparir
 il seguente codice:
    IfStatus SELF, 01
    ChangeStatus SELF, 00
    ChangeShape SELF, 00
    Else
    ShowText La porta
 chiusa
    EndIf
Che "tradotto" significa:
    Se lo Status dell'oggetto stesso (SELF, porta)
    Cambia lo Status dell'oggetto stesso (SELF, la porta) a 0
    Cambia l'immagine dell'oggetto stesso (SELF, sempre la porta) a 0 (la
      porta chiusa)
    Altrimenti
    Mostra Il Testo "La porta
 chiusa"
La programmazione del nostro oggetto "door"
 terminata.  Premete il
bottone OK per tornare al Doopsi Editor.
Tutorial 2
In questo tutorial mostreremo come modificare le caratteristiche di un
oggetto da un altro oggetto.  Questo tutorial presuppone che voi abbiate
 creato due oggetti, uno chiamato "lamp" con due immagini, una di
lampadina spenta ("light_off") ed una accesa ("light_on"); e l'altro
chiamato "button", con una sola immagine, di bottone.
- Selezionate l'oggetto "button" ed entrate nel Doopsi Coder.
- Premete sul bottone "Spingi", per editare il codice riferito alla
pressione da parte del giocatore del bottone "button".
- Eseguite queste operazioni:
    - Comando "IfStatus"
    - Selezionate "lamp"
    - Inserite 0
    - Comando "ChangeStatus"
    - Selezionate "lamp"
    - Inserite 1
    - Comando "ChangeShape"
    - Selezionate "lamp"
    - Selezionate "light_on"
    - Comando "Else"
    - Comando "ChangeStatus"
    - Selezionate "lamp"
    - Inserite 0
    - Comando "ChangeShape"
    - Selezionate "lamp"
    - Selezionate "light_off"
    - Comando "EndIf"
Nella finestra di codice di Doopsi Coder, comparir
 il seguente programma:
    IfStatus lamp, 00
    ChangeStatus lamp,01
    ChangeShape lamp,01
    Else
    ChangeStatus lamp,00
    ChangeShape lamp,00
    EndIf
Che "tradotto" significa:
    Se lo Status della lampada ("lamp")
 0 (la lampada
 spenta)
    Cambia lo Status di lamp in 1 (lampada accesa)
    Cambia l'immagine di lamp a "light_on"
    Altrimenti (la lampada
 accesa)
    Cambia lo Status di lamp a 0 (lampada spenta)
    Cambia l'immagine di lamp a "light_off"
Come vedete dal codice, non abbiamo dovuto programmare l'oggetto "lamp",
eppure l'oggetto modifica il suo stato (anche grafico) man mano che il
giocatore preme il pulsante "button".  Naturalmente, questo tutorial
molto semplice, ma
 possibile creare dipendenze molto complesse tra
oggetti differenti, rendendo il gioco finale ricco e articolato.
Descrizione generale.
Prima di tutto dovete selezionare l'azione che vi apprestate a programmare:
per far ci
 premete uno dei nove bottoni "Azioni Possibili" che compaiono
nell'angolo in alto a sinistra della finestra; il nome dell'azione scelta
comparir
 nel campo "Azione Corrente" sul fondo della finestra.
Per inserire una qualsiasi istruzione eseguite le seguenti azioni:
cliccate sul nome dell'istruzione desiderata contenuta nel lister che si
trova alla destra delle "Azioni Possibili"; l'Editor vi chieder
riempire qualsiasi argomento l'istruzione potrebbe avere.  Dopo aver
soddisfatto tutte le richieste potrete vedere apparire la linea di codice
nell'area del programma (il grosso rettangolo con un linea evidenziata in
esso).  La barra nell'area del programma
 una specie di cursore che
evidenzia la linea corrente.  L'istruzione che state editando verr
inserita prima di quella evidenziata.  Potete muovere il cursore cliccando
direttamente sull linea scelta oppure usando i gadget U (Up), D (Dowm), T
(Top) e B (Bottom).  Per eliminare una linea premete semplicemente il
bottone "Uccidi".
I gadget:
Nella zona in alto a sinistra vi sono i nove gadget per selezionare una
delle nove azioni da programmare.  Alla destra di questa zona vi
lister con tutte le istruzioni del linguaggio Doopsi.  Gli altri gadget
sono:
T              Sposta all'inizio del codice.
B              Sposta alla fine del codice.
U              Sposta in su di una linea. (Per muovervi su una linea potete
               cliccare direttamente su quella linea.)
D              Sposta in gi
 di una linea.  (Per muovervi su una linea
               potete cliccare direttamente su quella linea.)
Uccidi         Rimuove la linea di codice attualmente evidenziata.
---------------------------------------------------------------------------
****************
L' AnimWorkshop.
****************
Questo editor vi permette di creare animazioni mettendo in sequenza alcune
immagini.  Il risultato
 che potete mutare un semplice Oggetto in qualcosa
di pi
 complesso chiamato AnimObject, ovvero un oggetto contenente
un'animazione.  Tale animazione verr
 visualizzata quando l'AnimObject
disegnato sulla scena.
Iniziamo con un veloce TUTORIAL:  "assemblare un pendolo"
- Create un nuovo oggetto con "Pendolo" come nome interno.
- Attivate AnimWorkshop.
- Premete il gadget "Carica Frames" e, utilizzando il file requester,
selezionate l'immagine denominata "pendulum.000".  AnimWorkshop caricher
le tre immagini chiamate "pendulum.000", "pendulum.001" e "pendulum.002".
- Selezionate il fotogramma numero 0 e cliccate sul gadget "Agg Frame";
selezionate il fotogramma numero 1 e cliccate sul gadget "Agg Frame";
ripetete il tutto anche per il terzo ed ultimo fotogramma.
- Premete il gadget "Ping-Pong" per creare un'animazione di tipo Ping-Pong
(nel nostro caso verr
 aggiunto un solo fotogramma).
- Scrivete 3 nel gadget del "Frame Rate".
- Premete "Anima" per vedere l'animazione e il tasto destro del mouse per
fermarla.
- Premete il gadget "Ok" per uscire da AnimWorkshop.
Ed eccovi un tutorial pi
 difficile su "come costruire l'Omino":
- Per prima cosa create un nuovo oggetto utilizzando l'editor degli
Attributi (suppongo che sappiate gi
 fare questo) e chiamatelo (nome
interno) "OminoDestra".  Ora siete pronti per attivare AnimWorkshop.
- Premete il bottone "Carica Frames" e, utilizzando il file requester,
selezionate l'immagine chiamata "man_walk_right.000":  AnimWorkshop
caricher
 questa immagine e tutte le seguenti col medesimo nome e numero
crescente; questi fotogrammi saranno disegnati su un nuovo schermo.  Potete
scorrere le immagini utilizzando i gadget "Prec" e "Succ" nella parte alta
della finestra.
- Posizionatevi sul fotogramma numero 1 (il fotogramma 0
 quello "a
riposo" e lo prender
 in considerazione pi
 tardi) e premete il bottone
"Agg Frame":  il numero 1 apparir
 nella finestra della Sequenza.  Ora
muovetevi sul fotogramma numero 2 e premete ancora su Agg Frame; ripetete
queste azioni fino a quando anche l'ultimo fotogramma far
 parte della
sequenza.
- Ora potete inserire il frame rate nel gagdet "Frame Rate":  scrivete 12 e
premete Return.
- La vostra animazione
 completa:  premete il gagdet "Anima" per
ammirarla.
- Fermate l'animazione premendo il tasto destro del mouse.  Ora potete
uscire da AnimWorkshop premendo il bottone "Va Bene" o "Cancella" a seconda
se siete soddisfatti della vostra animazione o meno.
- E il frame numero 0?  Non si pu
 includerlo nell'animazione perch
fotogramma "a riposo", ma il Player ha bisogno di sapere quale frame usare
quando l'Omino
 fermo:  quindi noi lo agganciamo al nostro oggetto Omino e
puntiamo ad esso mediante il campo "Immagine Corrente" nell'editor degli
Attributi.  (Ovviamente questo campo non ha significato alcuno per una
animazione qualunque.)
- Un'ultima nota:  se ora attivate l'editor degli Attributi vedrete tutte
le immagini agganciate al nostro AnimObject mediante AnimWorkshop.  Questo
significa che potete agganciare i fotogrammi anche utilizzando l'editor
degli Attributi se preferite.
Descrizione generale.
A questo punto suppongo che sappiate gi
 come creare un nuovo oggetto.  Se
volete convertire tale oggetto in un AnimObject allora attivate
l'AnimWorkshop.  Se l'utente ha gi
 agganciato alcune immagini a questo
oggetto utilizzando l'editor degli Attributi allora tali immagini saranno
caricate e visualizzate immediatamente; se una o pi
 immagini non vengono
trovate l'editor segnaler
 un errore e le immagini mancanti rimarranno
vuote.  In alternativa
 possibile caricare le immagini mediante
AnimWorkshop stesso:  ma si tenga presente che in questo caso le immagini
devono costituire una sequenza sul disco, vale a dire che devono avere
tutte il medesimo nome seguito da un punto e da un numero a tre (tre, non
quattro o due!) cifre, ad es.  "pippo.000".  Quindi, quando l'utente
seleziona il gadget Carica Frames, AnimWorkshop aprir
 un file requester:
l'utente deve selezionare la prima immagine della sequenza (che non deve
necessariamente essere quella numerata "pippo.000"; potete iniziare
dall'immagine "pippo.154" se vi piace), ed allora l'editor proseguir
caricando tutte le immagini che trova con il medesimo nome e con numero
crescente (ad es.:  "pippo.154", "pippo.155", e cos
 via) fino a quando
raggiunge l'ultima o non ha pi
 spazio per agganciare ulteriori immagini
all'oggetto corrente (il numero di immagini che un oggetto pu
 possedere
ovviamente limitato).
Dopo che avete caricato le immagini siete pronti per costruire la sequenza
dei fotogrammi.  Prima di tutto, vi sono due gadget nella parte alta della
finestra, chiamati "Prec" e "Succ", per scorrere i fotogrammi, e fra di
essi
 scritto il numero sequenziale del fotogramma visualizzato:  potete
inserirlo manualmente.  Dunque dovete agire come segue:  selezionate il
fotogramma da includere nella sequenza e premete il bottone Aggiugi Frame.
Semplice, no?  Il fotogramma verr
 inserito subito dopo la posizione
corrente, e voi saprete sempre qual
 la posizione corrente in quanto
evidenziata:  potete inoltre muovere questa specie di cursore utilizzando i
gadget "Prec" e "Succ" alla base della finestra o utilizzando i tasti
cursore.  A proposito, se occorre inserire un fotogramma prima del primo
(scusate il gioco di parole, ma rende l'idea) dovete muovere il cursore sul
primo fotogramma della sequenza e poi muoverlo ancora una volta verso
sinistra:  il cursore sparir
 fuori dalla finestra della Sequenza e siete
pronti per cliccare sul gadget "Aggiungi Frame".  Posso dirvi di pi
:  se
cliccate due volte sul numero di un fotogramma nella finestra della
Sequenza tale fotogramma sar
 visualizzato.  Rimuovere un fotogramma
ancora pi
 semplice:  posizionatevi sul fotogramma incriminato nella
Sequenza e cliccate sul bottone "Rimuovi Frame".
Veniamo ora alla descrizione dei gadget rimanenti.  Un modo comodo per
creare un'animazione a ping-pong
 quello di costruire la parte "ping" come
descritto precedentemente e poi selezionare il gadget "Crea Ping-Pong":
AnimWorkshop aggiunger
 alla vostra sequenza la parte "ping" ribaltata
(senza il primo e l'ultimo fotogramma) per creare la parte "pong".
Inoltre, se non siete soddisfatti della vostra sequenza potete sempre
eliminarla con una sola pressione del bottone "Cancella Sequenza".  Potete
comunicare ad AnimWorkshop la velocit
 della vostra animazione modificando
il valore del gadget "Frame Rate".  Ultimo ma non meno importante
gadget "Anima".  So che sapete a cosa serve questo, ma lasciatemi
aggiungere un'altra cosa:  Doopsi visualizza tutte le animazioni in loop,
ovvero la sequenza viene letta da sinistra a destra fino alla fine, e poi
ancora dall'inizio fino a quando non viene fermato.
I gadget:
Carica Frames     Carica una sequenza di fotogrammi. Una sequenza
                  composta da files con lo stesso nome ma con numero
                  sequenziale crescente (ad es.: pippo.000, pippo.001,
                  ...). Voi selezionate il primo nome della lista.
Prec              Muove al fotogramma precedente nella lista.
Succ              Muove al fotogramma successivo nella lista.
Agg Frame         Aggiunge alla sequenza il fotogramma attualmente
                  visualizzato.
Canc Frame        Cancella il fotogramma selezionato dalla sequenza. Voi
                  selezionate il fotogramma muovendo il cursore sopra di
                  esso.
Crea Ping-Pong    Crea un'animazione a ping-pong modificando la vostra
                  sequenza di fotogrammi.
Frame Rate        Cambia il frame rate dell'animazione.
Cancella Sequenza Elimina la sequenza di fotogrammi.
Anima             Mostra l'animazione.
Prec              Va al fotogramma precedente nella sequenza (potete usare
                  anche i tasti cursore).
Succ              Va al fotogramma successivo nella sequenza.
---------------------------------------------------------------------------
**********************
L'Editor dei Dialoghi.
**********************
Introduzione.
In ogni avventura che si rispetti, devono essere presenti dei dialoghi tra
 personaggi.  Migliori sono i dialoghi, pi
 brillanti sono le
conversazioni, pi
 divertente risulta l'avventura.  Creare i dialoghi non
un compito facile da eseguire:  bisogna tenere in considerazione moltissimi
elementi e prevedere una risposta differente ad ogni frase che
 possibile
dire.  E' per questo motivo, che vi consigliamo vivamente di pianificare
attentamente i vostri dialoghi e di tracciare su carta dei veri e propri
diagrammi nei quali descrivere in maniera molto "visiva" come dovrebbe
essere strutturato un dialogo.
In Doopsi i dialoghi possono essere strutturati in maniera molto potente e
versatile ed
 possibile scrivere dialoghi che richiamano altri dialoghi o
che saltano da una parte all'altra per poi tornare sui loro stessi passi.
Il Dialog Editor
 uno strumento semplice e funzionale che vi permetter
creare dialoghi complessissimi in un brevissimo spazio di tempo:
attenzione per
, perch
, come vi abbiamo gi
 detto, se non pianificherete
prima tutto il dialogo, rischiate veramente di perdere, per cos
 dire, il
filo del discorso.
 un dialogo:
Un Dialogo, in DOOPSI,
 formato da una sequenza pi
 o meno lunga di
pagine.  Come per tutti gli altri elementi di Doopsi anche le pagine di
dialogo hanno il loro proprio "nome interno" che le identifica
univocamente.
Per il resto, una pagina
 formata da una "risposta", che
 la frase che
 l'interlocutore all'Omino, e una o pi
 frasi selezionabili
dall'utente, come risposta alla "risposta"...  hmmm, detto cos
sembrare un p
 confuso, cerchiamo di spiegare meglio, con un esempio:
iniziamo subito con il tutorial.
Tutorial 1 - Un Breve Dialogo
Per entrare nel Dialog Editor, premete semplicemente il bottone
"Dialog Editor" presente nella Finestra Principale.
   - Premete il bottone "Nuova" per creare una nuova pagina di dialogo.
     Vi verr
 mostrato un requester per l'inserimento del nome della
     pagina. Dal momento che questa pagina verr
 utilizzata come
     punto di partenza, sar
 meglio darle un nome significativo,
     scrivete quindi "Partenza_Dialogo".
     Adesso siete in grado di iniziare a scrivere le frasi vere e proprie.
   - Premete il bottone "Agg." in basso a sinistra, per aggiungere una
     nuova frase. La stringa "Nuova Frase" comparir
 nel gadget chiamato,
     per l'appunto, "Frase:". Cancellate "Nuova Frase" ed inserite invece
     questo: "Ciao, come stai?"
   - Ripetete adesso il punto 2, inserendo per
 i messaggi:
     "Come va!" e "Adesso devo proprio andare".
   - Adesso dovremo creare una seconda pagina, premiamo "Nuova" e mettiamo
     come nome "Come_Stai", cos
 ci ricorderemo che quello che
     immetteremo in questa pagina sar
 in risposta a "Ciao, come stai?"
     della pagina precedente.
   - Nel gadget in alto, dove c'
 scritto "Risposta:", scrivete "Bene!",
     questa
 la risposta che il nostro interlocutore ci dar
     Scrivere qualcosa in questo campo, non
 strettamente necessario,
     ma
 sempre meglio fare in modo che il nostro interlocutore dica
     qualcosa... altrimenti il nostro dialogo si potrebbe trasformare
     in un "monologo".
     L'unica situazione nella quale si pu
 effettivamente omettere una
     stringa di risposta,
 nella prima pagina del nostro dialogo,
     quando, cioe, "attachiamo bottone" con chi vogliamo parlare.
   - Ripetiamo il passo 2 e scriviamo solo una frase che dica
     "Ora vado, ciao".
   - Adesso dobbiamo preoccuparci di "agganciare" le due pagine di dialogo.
     Per farlo, torniamo alla prima pagina di dialogo. Permete il
     gadget "Seleziona": comparir
 un Lister con i nomi delle pagine di
     dialogo, nel nostro caso, ci saranno due nomi: "Partenza_Dialogo" e
     "Come_Stai". Selezionate "Partenza_Dialogo".
     La finestra del Dialog Editor, mostrer
 di nuovo la pagina che
     abbiamo editato in precedenza.
   - Adesso premete sulla frase "Ciao, Come Stai?", che comparir
     gadget di stringa (se volete, potrete anche editarla e modificarla)
     e poi premete sul bottone chiamato "Salto:", apparir
 lo stesso
     Lister che abbiamo appena incontrato. Questa volta, selezionate la
     frase "Come_Stai": il nome di questa pagina comparir
 nel gadget
     di stringa "Salto:"
     Ecco fatto! Adesso, quando, durnate il gioco, l'utente selezioner
     la frase "Ciao! Come Stai?", l'interlocutore risponder
 "Bene!".
     E' stato facile, no?
   - Giusto per sport, agganciamo anche alla frase "Come Va?", la pagina
     "Come_Stai". Premete su "Come Va?", poi su "Salto:" e selezionate
     "Come_Stai".
NOTA: una stringa Senza salto significa FINE DEL DIALOGO. Quando l'utente
      seleziona una di queste frasi, il dialogo termina.
      Nel nostro esempio abbiamo ben due frasi di questo tipo: una
     "Adesso devo proprio andare" nella prima pagina e "Ora vado, ciao"
      nella seconda pagina.
NOTA2: per convenzione, la frase che fa "uscire" dalla modalit
 di dialogo

 l'ultima tra le scelte possibili. Dove potete, mantenete
       inalterata questa convenzione.
Descrizione generale.
Il Dialog Editor
 utilizzato per creare dialoghi fra l'Omino ed un'altro
Oggetto sulla scena.  Come abbiamo avuto occasione di dire introducendo
questo editor, un dialogo
 costituito da un numero di pagine agganciate
fra di loro; qualunque pagina pu
 essere la prima pagina:  il nome della
prima pagina verr
 passato come argomento all'istruzione ShowDialog nel
Doopsi Coder.  Tutte le altre pagine del dialogo seguono automaticamente
poich
 sono agganciate assieme mediante il campo "Salto".
Descriviamo ora il contenuto di una pagina.  In ciascuna pagina vi
campo "Risposta" che contiene la frase che l'Oggetto dice quando
 il suo
turno di parlare:  questo
 il primo campo che il Player guarda quando
visualizza un dialogo.  Questo implica che se la prima pagina ha il campo
"Risposta" non vuoto, allora la conversazione viene iniziata dall'Oggetto.
Quando l'Oggetto ha finito di parlare (ovvero, quando l'utente, durante il
gioco, ha premuto il bottone del mouse per cancellare il testo che appare
sulla scena), tutte le frasi contenute nel grosso lister sotto il campo
"Risposta" vengono visualizzate nello spazio riservato alla console.  Il
Player attende che l'utente selezioni una frase e la visualizza sulla scena
(aspettando ancora che l'utente cancelli il testo prima di proseguire).
Poi il Player esamina il contenuto del campo "Salto":  se non
 vuoto, il
Player cerca una pagina con il nome uguale alla stringa contenuta nel campo
"Salto".  Alla fine, se questa pagina
 stata trovata il processo
ricomincia da capo:  viene visualizzata prima la risposta, poi le scelte al
di sotto di essa, e cos
 via.  Un dialogo incontra la propria fine quando
il campo "Salto" della frase selezionata
 vuoto oppure la pagina
agganciata non viene trovata.
Per costruire un dialogo dovete prima creare alcune pagine.  Il bottone
"Nuova" sulla destra crea una nuova pagina e chiede il nome da attribuire a
tale pagina:  questo nome
 l'identificatore che Doopsi usa per indirizzare
la pagina, quindi dovete fare attenzione a non utilizzare due volte lo
stesso nome.  Per modificare la risposta, scrivetela semplicemente nel
gadget stringa "Risposta".  Per aggiungere una nuova frase dovete premere
il bottone "Agg.":  il testo "Nuova Frase" apparir
 sia nel lister, sia nel
gadget stringa sotto di esso.  Ora potete modificare tale frase scrivendola
nel gadget stringa "Frase":  il nuovo testo rimpiazzer
 quello vecchio nel
lister.  Nel campo "Salto" va inserito il nome della pagina a cui saltare
quando la frase corrente viene selezionata durante il gioco:  potete
modificare tale nome inserendolo a mano nel gadget stringa oppure premendo
il bottone "Salto"; quest'ultimo apre un lister con tutti i nomi delle
pagine create fino ad ora:  cliccate sul nome desiderato e poi sul gadget
"Va Bene".
Ora descriviamo i rimanenti gadget nella fila in basso.  Il bottone
"Memorizza" immagazzina il contenuto del campo "Frase" nel lister (
stesso che premere il tasto Return nel campo "Frase").  Il gadget
"Seleziona" vi permette di muovervi attraverso le pagine:  quando lo
premete appare un lister con i nomi delle pagine create fino ad ora, e
potete selezionare quella da visualizzare.  Il gadget "Rimetti" annulla
l'ultima modifica apportata al campo "Frase".  Il bottone "Canc" rimuove la
frase correntemente selezionata.
I gadget nella colonna a destra hanno i seguenti significati.  Il gadget
"Nuova" crea una nuova pagina.  Il bottone "Salva" salva tutte le pagine
create sino ad ora, e il gadget "Carica" carica un insieme di pagine
salvate con il bottone precedente.  Il gadget "Nome Pag." vi permette di
cambiare il nome della pagina corrente.  Il bottone "Uccidi Pag." rimuove
solo la pagina corrente e il bottone "Uccidi Tutto" elimina tutte le
pagine create.
I Gadget:
Iniziamo con i gadget a destra sullo schermo:
Nuova             Crea una nuova pagina.
Carica            Carica un insieme di pagine.
Salva             Salva le pagine create.
Nome Pag.         Modifica il nome della pagina attuale.
Uccidi Pag.       Elimina la pagina corrente.
Uccidi Tutto      Elimina tutte le pagine create.
Ed ecco i bottoni in basso:
Agg.              Aggiunge una nuova frase.
Memorizza         Memorizza la pagina corrente.
Seleziona         Permette di selezionare una pagina di dialogo.
Rimetti           Rimette l'ultima frase modificata.
Canc              Cancella la frase attuale.
---------------------------------------------------------------------------
***********
Preferenze.
***********
Doopsi
 un programma complesso e flessibile ed alcune delle sue
caratteristiche possono essere adattate alle esigenze del programmatore.
In Doopsi, le modifiche possono essere effettuate tramite la finestra di
Preferences, suddivisa in quattro sezioni, che esamineremo singolarmente.
Selezione dei Percorsi.
In questa sezione
 possibile scegliere le directory contenenti tutti i
file di un determinato tipo.  Creando delle avventure complesse,
 sempre
meglio suddividere grafica, suoni e tutto il resto in varie directory.  Con
questi percorsi, ogni volta che sar
 necessario un file requester di un
determinato tipo (ad esempio per caricare un fondale) la directory verr
automaticamente impostata a quella inserita nelle preferenze.  Nel caso non
si desideri utilizzare alcune delle directory di default, sar
 sufficiente
inserire all'interno del campo una stringa vuota.
Il secondo gruppo di percorsi di default
 dedicato al Player:  essi
servono al Player per trovare i file che sono indispensabili per iniziare
il gioco, vale a dire il file contenente la console (default:
"Doopsi:Data/panel.iff"), il file "player.dat" (default:
"Doopsi:Data/player.dat") ed infine (opzionale) il catalogo per un
linguaggio diverso dall'inglese (default:  "Doopsi:Data/player.catalog").
In questi string gadget occorre quindi inserire, oltre al percorso
completo, anche il nome dei file.  Questo permette, ad esempio, di
utilizzare una console diversa per ciascuna avventura.
L'ultimo string gadget, chiamato "Player", contiene il percorso completo ed
il nome del programma "DoopsiPlayer":  questo serve all'Editor per trovare
il Player quando viene premuto il bottone "Prova Gioco" nella Finestra
Principale.
A fianco del gadget di stringa contenente il path, c'
 un piccolo gadget
con scritto "R" (ricerca), che aprir
 un path requester con il quale sar
possibile cercare la directory che desideriamo impostare come default.
Manipolazione dei Colori.
In questa sezione
 possibile caricare, editare e salvare i colori
dell'interfaccia dell'editor di Doopsi.  Premendo "Carica" sar
 possibile
caricare i primi quattro colori di una qualsiasi immagine IFF, con "Salva"
potremo salvare la palette e con "Edita" apparir
 un Palette requester con
il quale sar
 possibile modificare direttamente i colori.
Scelta dei nomi di Default.
Questa
 forse la sezione pi
 importante delle preferenze.  Come dovreste
sapere, Doopsi utilizza per il personaggio dell'avventura dei nomi di
default necessari perch
 il Player utilizzi le animazioni corrette quando
necessario.  Potete trovare la spiegazione di come questo meccanismo
funzioni nella sezione "Alcune note su come il Player trova l'Omino" posta
immediatamente dopo la sezione del manuale realtiva alla Finestra
Principale.  Seguono i nomi dei campi ed il loro significato:
NOME         VALORE DEF.  DESCRIZIONE
Root         Man          E' il nome "base" mediante il quale sono definiti
                          i nomi delle animazioni dell'Omino.
Left         L            Questi quattro valori determinano
Right        R            le animazioni del personaggio nelle varie
Up           U            direzioni. Ad es. "ManU" significa
Down         D            "animazione Omino che cammina verso l'alto"
Talk         Talk         Questa
 una specie di "seconda root" ed

 il suffisso che viene aggiunto DIRETTAMENTE
                          alla Root vera e propria per definire le
                          animazioni del personaggio mentre parla.  A
                          questa root verr
 poi aggiunto normalmente un
                          suffisso Left, Right, Up o Down.  Per es.  il
                          personaggio che parla a sinistra
 definito cos
                          ManTalkL.

Questi nomi, essendo solo "interni" al Player, potevano anche rimanere
"rigidi" e non essere modificabili, ma abbiamo preferito permetterne la
modifica, per poter rendere tutto ancora pi
 leggibile.  Infatti, potrete
modificare questi nomi, assegnando valori pi
 significativi.  Facciamo un
esempio:
  Root = Uomo
  Talk = _che_parla
  L    = _a_sinistra
  R    = _a_destra
Il famigerato ManTalkL diventer
 "Uomo_che_parla_a_sinistra", sicuramente
 elegante.  Ma attenzione, questo
 solo un esempio:  i nomi interni
degli Oggetti in Doopsi possono essere di massimo 30 caratteri.
Scena di Partenza.
Con questa ultima parte della finestra di Preferences
 possibile definire
il nome della prima scena che verr
 mostrata all'avvio dell'avventura.
I bottoni USA/CARICA/SALVA/ANNULLA
I bottoni presenti in fondo alla finestra di Preferences permettono di
usare le preferenze appena inserite ("USA"), salvarne le preferenze attuali
("SALVA"), caricare una configurazione precedentemente salvata ("CARICA") e
di annullare i nuovi settaggi ("ANNULLA").
Nota:  le preferenze vengono SEMPRE salvate in un file completo di Doopsi,
per permettere la gestione di pi
 avventure differenti contemporaneamente
con settaggi diversi.
---------------------------------------------------------------------------
********************************
Appendice A:  Istruzioni Doopsi.
********************************
Nella seguente lista oggetti e scene sono identificati utilizzando il loro
nome interno, quindi Oggetto rappresenta il nome interno dell'Oggetto
stesso, e cos
 via.
AddStatus Oggetto, Valore
Aggiunge Valore al campo di stato dell'oggetto selezionato.  Il valore
totale dello stato di un oggetto
 compreso fra -32767 e +32768.
ChangeDescription Oggetto, Testo
Cambia il nome dell'oggetto in Testo.  Questo nome
 quello che appare
sulla linea di testo della console quando l'oggetto viene selezionato sulla
scena.
ChangeScene Scena
Se Scena
 stata trovata questa istruzione esce dalla scena corrente e
visualizza la nuova scena.
ChangeShape Oggetto, Immagine
Cambia l'immagine attuale dell'Oggetto selezionato.  Se l'Oggetto
visualizzato sulla scena la nuova immagine verr
 disegnata e rimpiazzer
quella vecchia.  Se l'oggetto
 nell'inventario questo comando modificher
l'immagine di inventario (e la ridisegner
).  Infine, se l'Oggetto non
visualizzato questa istruzione modificher
 solo il valore dell'immagine
attuale dell'Oggetto stesso.  Questa istruzione non funziona con gli
AnimObject o con le Zone Vuote (per ovvi motivi) quando sono disegnate
sulla scena, ma le loro immagini di inventario potranno comunque essere
modificate.  Con ChangeShape l'immagine attuale dell'Oggetto
 cancellata
perch
 la nuova immagine viene ridisegnata immediatamente sopra essa:
questo implica che le due immagini devono avere le medesime dimensioni.
ChangeShapeBG Oggetto, Immagine
Questo comando
 simile a ChangeShape, ma prima di disegnare la nuova
immagine il Player cancella l'immagine attuale dell'Oggetto ridisegnando lo
sfondo.  Questo elimina la limitazione presente in ChangeShape che la nuova
immagine debba avere dimesioni uguali o maggiori di quella vecchia.
ChangeStatus Oggetto, Valore
Scrive Valore nel campo di stato dell'Oggetto selezionato.  Lo stato pu
essere 0 o 1 per rappresentare una porta chiusa o aperta rispettivamente, e
 via...  Se l'oggetto
 una moneta questo campo pu
 essere usato per
memorizzare il numero di monete che l'Omino possiede.  Il valore che il
campo di stato di un oggetto pu
 contenere va da -32767 a +32768.
Close Oggetto
Si veda l'istruzione Open.
ConsoleHide
Spegne la console.
ConsoleShow
Accende la console.
Drop Oggetto
Si veda l'istruzione Open.
Else viene usato in un gruppo If:  se la condizione
 falsa allora il
Player eseguir
 tutte le istruzioni che seguono il comando Else fino al pi
vicino EndIf (o fino alla fine del programma se quest'ultimo non
presente).
EndIf
Questa istruzione termina un gruppo If.  Potete avere fino a 10 gruppi If
nidificati.
EraseInventory Oggetto
Rimuove l'Oggetto dalla lista dell'inventario e cancella la sua immagine di
inventario dalla console.
EraseObject Oggetto
Rimuove l'Oggetto dalla scena.  Questa istruzione non si applica agli
AnimObject:  in questo caso l'utente deve utilizzare StopAnim.
GetInventory Oggetto
Aggiunge l'Oggetto alla lista dell'inventario e disegna la sua immagine di
inventario attuale sulla console.  Questa istruzione fallisce se la lista
dell'inventario
 piena, in quanto essa pu
 contenere solo un numero
limitato di oggetti.
IfOnScene Oggetto
Restituisce Vero se l'Oggetto
 disegnato sulla scena.
IfSceneIs Scena
Restituisce Vero se l'Omino
 attualmente nella scena Scena.
IfStatus Oggetto, Stato
Restituisce Vero se il campo di stato dell'Oggetto selezionato
 uguale a
Stato.
IfUsedWith Oggetto
Restituisce Vero se l'oggetto corrente
 usato con Oggetto.  Questo
significa che avete prima selezionato il bottone Usa e cliccato una volta
su Oggetto e poi, dopo che il testo "Usa Oggetto con..."
 apparso sulla
console, avete cliccato due volte sull'oggetto corrente:  questo attiva il
programma Doopsi relativo all'azione Usa dell'oggetto corrente dove
dovrebbe trovarsi questa istruzione.  Affinch
 cliccando su Oggetto appaia
la scritta "con..." ed il Player attenda la selezione di un altro oggetto
necessario che Oggetto abbia UseWith come prima istruzione del programma
relativo all'azione Usa.
InvToScene Oggetto
Preleva l'Oggetto selezionato dall'inventario e lo disegna sulla scena alle
coordinate contenute in Oggetto:  tali coordinate sono inizializzate quando
l'Oggetto viene posizionato sulla scena mediante l'Editor.  Se l'oggetto
un AnimObject l'animazione verr
 automaticamente visualizzata.
InvToSpot Oggetto, Spot
Uguale a InvToScene, ma l'Oggetto verr
 disegnato alle coordinate dello
Spot.
Look Oggetto
Si veda l'istruzione Open.
ManDirection Estensione
Forza l'Omino a girarsi nella direzione selezionata:  Estensione
delle quattro estensioni indicanti una direzione che l'utente pu
modificare mediante l'editor di preferenze.
ManTalkColour Valore
Con questa istruzione l'utente sceglie il registro colore da usare per il
testo in tutte le successive istruzioni ShowText o ShowDialog quando
l'Omino parla.
MoveMan Spot
Questa istruzione permette all'utente di forzare l'Omino a muoversi verso
lo Spot desiderato sulla scena.
MoveObject Oggetto, Spot
Muove l'Oggetto dalla sua posizione attuale sulla scena alla posizione
specificata da Spot.  Durante il movimento un AnimObject verr
 sostituito
all'immagine corrente dell'Oggetto se tale AnimObject
 stato
precedentemente selezionato mediante l'istruzione SetMoveAnim.
MoveObjectOnPath Oggetto, Spot
Questo
 simile a MoveObject con la differenza che l'Oggetto selezionato si
muover
 seguendo il percorso della scena corrente e si fermer
 al nodo pi
vicino allo Spot selezionato.  Un'altra leggera differenza
 che si suppone
che l'hot-spot dell'oggetto (o, se presente, dell'animazione che lo
sostituisce) sia posizionato nell'angolo in basso a sinistra
dell'immagine.
MoveObjectToObject Oggetto1, Oggetto2
Questo
 simile a MoveObject, e muove Oggetto1 alla posizione specificata
da Oggetto2.
MoveObjToObjOnPath Oggetto1, Oggetto2
Questo
 simile a MoveObjectOnPath, e muove Oggetto1 alla posizione
specificata da Oggetto2.
MusicPause
Sospende momentaneamente la musica.  Per farla ripartire basta utilizzare
un'altra volta questo comando.
MusicPlay File
Suona il contenuto del File.  File deve essere un modulo tracker standard.
MusicStop
Interrompe la musica.
ObjTalkColour Valore
Questo
 simile a ManTalkColour, ma vi permette di scegliere il registro
colore del testo dell'oggetto a cui l'Omino sta parlando durante una
istruzione ShowDialog.
Open  Oggetto
Close Oggetto
Look  Oggetto
Take  Oggetto
Drop  Oggetto
Push  Oggetto
Pull  Oggetto
Talk  Oggetto
Use   Oggetto
Queste istruzioni eseguono il codice Doopsi contenuto nella corrispondente
azione di Oggetto.  Esse sono gestite come sottoprogrammi, e potete
nidificare fino ad un massimo di 10 sottoprogrammi.
Pull Oggetto
Si veda l'istruzione Open.
Push Oggetto
Si veda l'istruzione Open.
PutObject Oggetto, Spot
Disegna l'Oggetto alla posizione dello Spot.  Oggetto pu
 anche essere una
Zona Vuota.
SceneToInv Oggetto
Preleva l'Oggetto selezionato dalla scena e lo ripone nell'inventario.  Se
l'oggetto
 un AnimObject l'animazione verr
 automaticamente fermata.
SetManName Oggetto
Questa istruzione serve per cambiare le animazioni dell'Omino:  la radice
del nome (cio
 dopo aver rimosso qualunque estensione) dell'Oggetto
utilizzata per costruire i nomi dell'Omino fino a quando SetManName viene
chiamata nuovamente o
 invocata da un nodo del percorso.
SetMoveAnim AnimObject
L'AnimObject selezionato verr
 usato come animazione per la seguente
istruzione MoveObject o simili (MoveObjectOnPath, MoveObjectToObject,
MoveObjToObjOnPath).  Se il nome dell'AnimObject termina con una delle
quattro estensioni (indicanti le quattro direzioni) allora il Player
autorizzato a scegliere la direzione opportuna prima di muovere l'oggetto:
se tale direzione non
 fornita verr
 utilizzata l'immagine corrente
dell'oggetto, e quindi la selezione dell'animazione sar
 totalmente
ignorata.
SetTalkAnim AnimObject
Questa istruzione comunica al Player che, quando il prossimo ShowDialog
 eseguito, deve usare AnimObject per mostrare che l'oggetto
selezionato sta parlando.  Se l'utente termina il nome interno di
AnimObject mediante una delle quattro estensioni indicanti una direzione
(tali estensioni possono essere modificate usando l'editor di preferenze),
allora il Player rimuove questa estensione da tale nome interno e sceglie
la direzione appropriata (dipendente dalla posizione relativa dell'oggetto
rispetto all'Omino).  Poi aggancia l'estensione relativa alla direzione
scelta al nome interno di AnimObject e cerca l'oggetto risultante.  Se
questo viene trovato l'animazione corrispondente sar
 visualizzata quando
l'oggetto parla.
ShowAnim AnimObject
Questa istruzione visualizza l'animazione contenuta in AnimObject.  Tale
animazione verr
 posizionata alle coordinate interne di AnimObject:  queste
coordinate vengono inizializzate quando l'AnimObject
 posizionato sulla
scena mediante l'Editor (e rimangono memorizzate anche se l'AnimObject
viene rimosso dalla scena in un secondo tempo).  Il numero di animazioni
che il Player pu
 visualizzare contemporaneamente
 limitato.
ShowAnimAtSpot AnimObject, Spot
Visualizza l'animazione contenuta in AnimObject alle coordinate di Spot.
ShowDialog Dialogo
Questo comando inizia una conversazione tra l'Omino e l'oggetto
selezionato.  Dialogo
 la prima pagina della conversazione.  Se
l'animazione che mostra l'Omino che parla viene trovata essa sar
visualizzata; potete scegliere un'animazione che mostra l'oggetto che parla
mediante SetTalkAnim.  I colori dei testi dell'Omino e dell'oggetto vengono
scelti mediante le istruzioni ManTalkColour e ObjTalkColour
rispettivamente.
ShowPicture File
Nasconde momentaneamente la scena e la console per visualizzare il
contenuto del File.  File deve essere un'immagine Iff ILBM.  Se l'immagine
 grande dell'area dello schermo potete muoverla spostando il mouse
contro i bordi dello schermo.  Per ritornare allo stato precedente premere
il tasto sinistro del mouse.
ShowText Testo
Visualizza Testo.  La posizione e la suddivisione in linee del testo
verranno determinate automaticamente mediante la posizione dell'Omino sulla
scena e la larghezza della scena stessa.  La direzione dell'Omino determina
quale delle quattro animazioni verr
 visualizzata, se presente, per far
parlare l'Omino; se l'animazione non
 presente il Player non si lamenter
e si limiter
 a lasciare immutato l'Omino.  Il colore del testo pu
 essere
cambiato utilizzando l'istruzione ManTalkColour.  Per cancellare il testo
necessario premere il tasto sinistro del mouse.
SoundPlay File
Suona il contenuto del File.  File deve essere un campionamento Iff 8SVX
standard.
StopAnim AnimObject
Ferma l'animazione contenuta in AnimObject e la rimuove dalla scena.
Take Oggetto
Si veda l'istruzione Open.
Talk Oggetto
Si veda l'istruzione Open.
Use Oggetto
Si veda l'istruzione Open.
UseWith
Questa istruzione deve essere la prima nel programma dell'azione Usa di un
oggetto:  essa comunica al Player che l'oggetto corrente deve essere usato
insieme ad un altro oggetto; dunque il Player visualizza il testo "Usa
Oggetto con..." e aspetta che l'utente selezioni un altro oggetto.  Si veda
anche IfUsedWith.
---------------------------------------------------------------------------
*************************
Appendice B:  La console.
*************************
Lo schema della console incluso nel pacchetto di Doopsi mostra le diverse
zone controllate dal Player:  ci sono i nove bottoni delle azioni sulla
sinistra, due frecce verticali per far scorrere l'inventario e, fra queste,
un piccolo bottone usato per accedere all'interfaccia per il disco; la
parte destra
 occupata dall'inventario e, ultimo ma non meno importante,
il rettangolo all'estremit
 superiore
 la linea di testo dove appariranno
tutti i messaggi.  A proposito:  ciascun quadratino dell'inventario misura
32 * 32 pixel, quindi l'utente deve tener conto di queste dimensioni quando
progetta le immagini di inventario per i suoi oggetti.  Sotto la console,
sullo stesso schermo
 rappresentata l'interfaccia per il disco:  l'area
 vasta sulla sinistra
 quella in cui comparir
 la lista dei file e
sotto di essa vi
 lo spazio dove l'utente inserisce il percorso di ricerca
dei file stessi; poi vi sono due frecce verticali per scorrere la lista dei
file e cinque bottoni.
Lo schermo contenente la console e l'interfaccia disco deve essere in bassa
risoluzione non interlacciato e l'utente pu
 disegnarci sopra tutto quello
che desidera, ma deve ricordare di rispettare le dimensioni delle zone
delimitate.  Si ricordi anche che i quadratini dell'inventario, la linea di
testo e l'area dedicata alla lista dei file vengono riempite dal Player con
il colore numero 0.  Un altro suggerimento:  tutte le immagini di
inventario devono avere la medesima palette, quella della console, in
quanto appariranno sulla console e quest'ultima rimane fissa per tutta la
durata del gioco; invece le altre immagini possono avere palette differenti
poich
 permesso cambiare i colori passando da una scena all'altra.
L'interfaccia del disco.
E' come tutti gli altri requester a cui siete abituati:  il percorso di
ricerca viene inserito nel gadget stringa situato nella parte bassa dello
schermo e i nomi dei file vengono elencati nell'area sopra di esso.  Per
caricare un file l'utente deve selezionarne il nome con il taso sinistro
del mouse e poi cliccare sul bottone Carica alla destra dello schermo.  Per
salvare un file l'utente deve selezionarne il nome e poi cliccare sul
bottone Salva:  apparir
 un cursore per permettere all'utente di modificare
il nome del file; quando le eventuali modifiche sono state effettuate basta
premere Return per salvare.  Per salvare una nuova partita cliccate su
Salva come prima, senza selezionare alcun nome.
I nomi che compaiono nel lister ed il percorso di ricerca sono limitati ad
una lunghezza di 25 caratteri (penso sia abbastanza per la maggior parte
delle applicazioni).
I cinque bottoni sulla destra sono denominati, in ordine:  Carica, Salva,
Gioca, Workbench ed Esci.  I bottoni Carica e Salva sono gi
 stati
descritti.  Il bottone Gioca permette di ritornare allo schermo della
console e di continuare il gioco.  Il bottone denominato Workbench attiva
il multitasking:  il Player scompare e l'utente pu
 tornare alla partita
interrotta selezionando la voce Doopsi-GS nel menu Tools del Workbench.  Il
bottone Esci..., lascio a voi immaginare lo scopo di quello.
---------------------------------------------------------------------------
****************************
Appendice C:  Dentro Doopsi.
****************************
Nel seguito user
 il termine Doopsi quando descriver
 come funzionano
alcune parti comuni all'Editor ed al Player.
Struttura degli oggetti di Doopsi.
Per capire come Doopsi agisce e per ottenere il meglio da lui dovete
conoscere almeno l'essenziale della struttura degli oggetti Doopsi.
Iniziamo con una Scena:
   nome interno
   nome file dello sfondo
   lista di Oggetti agganciati (nomi interni)
Il nome interno
 un nome privato che l'utente attribuisce alla Scena ed
usato da Doopsi per riconoscere la Scena stessa.  Il nome dello sfondo
nome (completo di percorso) del file Iff contenente l'immagine da
visualizzare.  Segue poi una lista dei nomi interni degli Oggetti che
devono essere posizionati sulla Scena.
Veniamo ora ad un Oggetto. Vi sono tre tipi di oggetti, ma tutti
condividono la medesima struttura:
a) gli Oggetti tout-court sono semplicemente oggetti nel senso usuale del
termine e le loro immagini verranno disegnate sulla scena.
b) gli AnimObject contengono un'animazione che verr
 visualizzata sulla
scena.
c) le Zone Vuote sono costituite da un rettangolo (che non sar
 disegnato)
senza immagini.
Segue la struttura generale di un Oggetto:
   nome
   nome interno
   coordinata X
   coordinata Y
   Larghezza
   Altezza
   stato
   lista di immagini
   nove programmi di azione
Il nome
 che appare sulla linea di testo del Player quando il
puntatore
 sull'oggetto.  Il nome interno
 un nome privato (possibilmente
unico) che l'utente assegna all'oggetto ed
 usato da Doopsi per
riconoscere l'oggetto stesso:  se l'utente utilizza pi
 volte lo stesso
nome interno l'Editor non si lamenta, ma potreste ottenere risultati
imprevedibili (di solito Doopsi si ferma al primo oggetto che abbia il nome
interno richiesto).  Le coordinate X e Y specificano la posizione in cui
disegnare l'oggetto sullo schermo.  Larghezza ed Altezza sono le
dimensioni dell'oggetto.  Lo stato
 un valore intero con nessun
significato particolare:  pu
 essere usato per memorizzare lo stato
Acceso-Spento di una lampadina, o lo stato Aperto-Chiuso di una porta, o il
numero di monete che l'Omino possiede, e cos
 via...  Segue poi una lista
di tutte le immagini (nome del file completo di percorso del file Iff
contenente l'immagine) che l'utente ha agganciato all'Oggetto.  Infine vi
sono nove programmi (contenenti del codice Doopsi), uno per ciascun bottone
della console del Player.
Un AnimObject differisce dalla precedente descrizione per il fatto che
possiede anche una stringa di interi che specifica la sequenza in cui le
immagini verranno visualizzate.  Larghezza ed Altezza conterranno la
massima larghezza ed altezza rispettivamente di tutte le immagini
selezionate per l'animazione.
Una Zona Vuota differisce per il fatto che non verr
 disegnata sulla scena,
ma la sua posizione sar
 comunque rivelata da Doopsi.  La lista di
immagini, per
, non sar
 necessariamente vuota in quanto l'utente potrebbe
aver bisogno, ad esempio, di riporre questo oggetto nell'inventario (e
quindi necessita di un'immagine di inventario), e cos
 via.
---------------------------------------------------------------------------
**********
Il Player.
**********
La sequenza di avviamento.
Quando lanciate il Player, esso cerca prima di tutto il file principale di
Doopsi e, da questo momento in poi, tutte le azioni che intraprende sono
determinate dai dati che trova in tale file.  Dal file principale ricava il
percorso dove cercare la "console" (la parte bassa dello schermo dove
appaiono i bottoni e l'inventario), contenuta nel file "panel.iff", e il
file "player.dat".  Se non trova uno qualunque dei pezzi che ho appena
elencato si lamenta ed esce.
Supponendo che abbia svolto con successo i precedenti passi, il Player
cerca ora nel file Doopsi (il file principale che contiene tutta la
struttura del gioco) le animazioni del protagonista:  devono esserci
quattro animazioni, una per ciascuna direzione, con i nomi di default che
l'utente ha scelto.  Poich
 questi dati sono vitali (come fate a giocare se
non vedete dove siete?) il Player si ferma ed esce se non ha trovato tutto
quello che stava cercando.  Questo significa che esso deve trovare prima di
tutto i quattro Oggetti che contengono tali animazioni e poi deve trovare
anche tutte le immagini necessarie.  A proposito, se l'utente fornisce
anche le animazioni per far parlare il protagonista esse verranno caricate:
in questo caso non
 necessario fornire quattro animazioni se l'utente non
lo ritiene necessario poich
 tali animazioni vengono utilizzate solo se
presenti.  Ma ricordate, se l'utente chiede al Player di usare
un'animazione questa animazione deve essere completa, vale a dire che il
Player deve essere in grado di trovare tutte le immagini necessarie.
Questa
 una regola generale.
Ed ora veniamo al passo successivo:  fino ad ora il Player
 stato in grado
di visualizzare la console, ma la met
 superiore dello schermo
 ancora
terribilmente nera.  Allora esso cerca nel file Doopsi la scena che avete
scelto come prima scena usando l'editor di Preferenze:  se l'utente si
dimenticato di includere almeno una scena con tale nome allora il Player
non ha nient'altro da fare, perch
 non sa da quale scena iniziare il gioco,
ed esce ("ancora!" potreste esclamare, ma non penso che questo
comportamento sia dovuto a permalosit
).  Ovviamente esce anche se la scena
 stata trovata ma non
 presente il file Iff che contiene lo sfondo.
D'ora in poi il Player si lamenter
 soltanto, senza uscire, se non trover
qualcosa.  Errori comuni sono "Oggetto non trovato", se l'oggetto che
l'utente richiede non
 nella lista, o "File non trovato" se non trova il
file contenente un'immagine o uno sfondo, ecc...  In questi casi non
succede nulla ed il gioco continua indisturbato.  I messaggi di errore
vengono visualizzati sulla console, nella stessa linea in cui appare la
scritta "Vai verso"; per eliminare il messaggio e ritornare al gioco
l'utente deve premere il tasto destro del mouse.
Se una scena
 stata caricata con successo lo sfondo verr
 visualizzato e
tutti gli oggetti in essa contenuti saranno disegnati sullo schermo:  gli
AnimObject sono automaticamente riconosciuti ed animati.  Supponendo che
sappiate gi
 (dal manuale dell'Editor) cos'
 un percorso Doopsi, vi dico
che il Player cerca prima un nodo nel percorso della scena corrente con il
nome uguale a quello della scena da cui proviene, poi, se questo fallisce,
cerca un nodo che ha lo stesso nome della scena corrente; infine disegna
l'Omino (che guarda l'utente) vicino al nodo trovato.
 anche qualcosa di leggermente tecnico che dovete sapere a proposito dei
nodi:  questi vi permettono di fornire una animazione diversa da quella di
default per l'Omino e di decidere dove cambiare scena; inoltre il percorso
della scena pu
 essere influenzato da condizioni contenute nei suoi nodi.
Il Player legge il nome delle animazioni "custom", le condizioni ed i cambi
di scena da un nodo quando l'Omino ha i piedi sopra quel nodo:
l'animazione custom viene visualizzata solo quando l'Omino cammina dal nodo
attuale a quello successivo (cos
, se l'Omino si ferma sul nodo attuale voi
non potete vedere tale animazione e dovete fornire un fotogramma di riposo
all'animazione precedente), ma le condizioni e i cambi di scena sono letti
ed eseguiti immediatamente quando l'Omino arriva sul noto attuale.  Per
riassumere:  le animazioni custom di un nodo vengono eseguite quando
l'Omino si allontana da quel nodo, ma le condizioni e i cambi di scena
vengono eseguiti quando l'Omino arriva a quel nodo.
Alla fine il gioco inizia e voi diventate i protagonisti.
Errori.
Segue una breve descrizioni dei possibili errori.  I messaggi di errore
compaiono nella riga di testo e vengono cancellati premendo il tasto destro
del mouse.  Se l'errore
 del tipo "... non trovato ..." il Player stampa
anche il nome dell'oggetto (o del file, ecc.) che non ha trovato.
Oggetto non trovato:    l'oggetto non
 nella lista principale.
Scena non trovata:      la scena che avete richiesto non
 nella lista.
File non trovato:       non penso ci sia bisogno di spiegazioni per
                        questo.
Spot non trovato:       l'utente ha richiesto uno spot inesistente.
Inventario pieno:       la lista dell'inventario
 capiente ma limitata,
                        quindi se l'utente vi ripone troppi oggetti essa
                        pu
 traboccare.
Niente spazio per l'animazione:  il numero di AnimObject che il Player pu
                                 gestire contemporaneamente
 limitato.
Dialogo non trovato:    l'utente ha richiesto una pagina di dialogo che non
                        esiste.
Directory non trovata:  questo messaggio compare nel file lister: l'utente
                        ha specificato un percorso inesistente.
Niente spazio per l'oggetto:  il numero di oggetti che una scena pu
                              contenere
 limitato.
Profondit
 eccessiva:   l'utente ha tentato di disegnare sulla scena un
                        oggetto con profondit
 maggiore di quella della
                        scena stessa.
EndIf senza If:         in un programma Doopsi vi
 un'istruzione EndIf
                        senza il corrispondente comando If.
File Iff non valido:    dovete fornire un file Iff standard quando
                        esplicitamente richiesto, ad es.: nelle istruzioni
                        ShowPicture e SoundPlay.
Stack pieno:            si possono nidificare fino a 10 sottoprogrammi: se
                        ne aggiungete uno di troppo lo stack si esaurisce.
---------------------------------------------------------------------------
*****************
Limiti di Doopsi.
*****************
Qui sono riportate le limitazioni attuali di Doopsi:  le diciture
"Shareware" e "Special" indicano le limitazioni per le due versioni
dimostrative.
Editor:
Tipo                    numero Max
~~~~                    ~~~~~~~~~~
scene                   200         (Shareware: 3;  Special: 5)
oggetti                 500         (Shareware: 30; Special: 40)
pagine di dialogo       100         (Shareware: 5;  Special: 8)
linee per pagina di     12          (Shareware: 3;  Special: 4)
 dialogo
immagini per oggetto    15
oggetti sulla scena     20
 contemporaneamente
lunghezza nomi interni  30
Player: gli stessi dell'Editor pi
Tipo                    numero Max
~~~~                    ~~~~~~~~~~
animobject sulla scena  10
 contemporaneamente
oggetti in inventario   500         (Shareware: 30; Special: 40)
sottoprogrammi          10
 nidificati
gruppi If nidificati    10